Você está na página 1de 28

JPA e 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

Curso JPA e Hibernate

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

Curso JPA e Hibernate

1. Java Persistence API (JPA)


A Java Persistence API oferece aos desenvolvedores Java a instalao de um objeto (ou mapeamento) relacional de gerenciamento de dados relacionais em aplicaes Java. Java Persistence consiste em quatro reas: A Java Persistence API A linguagem de consulta A Java Persistence API Criteria Objeto / Metadados de mapeamento relacional

Comparativo entre os modelos: Desenvolvedores Java que precisam armazenar e recuperar dados persistentes possuem vrias opes disponveis: serializao, JDBC, JDO, Ferramentas Proprietrias Mapeamento Objeto-Relacional (ORM), Bancos de Dados Orientado a Objetos (ODB) e Beans de Entidade (EJB 2). Porqu usar outro framework de persistncia? A resposta a esta questo que, com a exceo de JDO, cada uma das solues de persistncia acima mencionados tem srias limitaes. JPA ultrapassa estas limitaes, como ilustrado pela tabela abaixo:
Suporte Serializao JDBC ORM ODB EJB 2 JDO JPA

Objetos Java Conceitos avanados de OO Integridade Transacional Concorrncia Conjunto Largo de Dados Existncia de Esquemas Relacional e No-Relacional Consultas Padres Estritos / Portabilidade Simplicidade

Sim Sim No No No No No No Sim Sim

No No Sim Sim Sim Sim No Sim No Sim

Sim Sim Sim Sim Sim Sim Sim Sim

Sim Sim Sim Sim Sim No Sim Sim

Sim No Sim Sim Sim Sim Sim Sim Sim No

Sim Sim Sim Sim Sim Sim Sim Sim Sim Sim Sim Sim Sim No Sim Sim Sim Sim Sim Sim

No No No No

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

Curso JPA e Hibernate

Java Persistence API Anotaes de metadados Java Persistence Query Language

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

Curso JPA e Hibernate

necessrio para manter os registros no banco de dados. Modelo de domnio representa os objetos de persistncia ou entidades no banco de dados. Uma entidade representa uma coleo de registros (Tabela). Uma entidade pode ser uma pessoa, lugar ou qualquer coisa sobre a qual deseja-se armazenar os dados no banco de dados. Um modelo de domnio rico inclui as caractersticas de todo o comportamento orientado a objetos como herana, polimorfismo e muitos mais. Ao desenvolver um aplicativo corporativo, primeiro projeto do modelo de objeto de domnio para manter os dados no banco de dados, ento, projetar o esquema de banco de dados com a ajuda do Administrador do Banco de Dados (DBA). A seguinte figura ilustra uma relao bi direcional de um para muitos entre a entidade Funcionrio e Departamento. As entidades ContratoPJ e ContratoCLT so herdadas da entidade Funcionrio.

Os princpios da JPA e framework de mapeamento O-R: Cada estrutura de mapeamento OR, como Oracle TopLink fornece trs instalaes: 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. O uso de uma linguagem de consulta para recuperar objetos a partir do banco de dados a maneira apropriada, uma vez que as declaraes imprprias SQL podem resultar em retardar o desempenho da operao de realizao, no banco de dados. Uma linguagem de consulta permite recuperar as entidades do banco de dados e poup-lo de escrever as instrues SQL SELECT.

JPA fornece um modo padro de usar a persistncia, fornecendo um mecanismo padro ou mapeamento, uma maneira de estender EJB-QL para recuperar entidades e uma API EntityManager para executar operaes CRUD. JPA fornece POJO (Plain Old Java Object) padro e mapeamento objeto relacional (ou mapeamento) para persistncia de dados entre aplicaes. Persistncia, que trata de armazenamento e recuperao de dados do aplicativo, agora pode ser programado com a JPA a partir de EJB 3.0 como resultado da JSR 220. Um dos grandes benefcios da JPA sua independncia.

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

Curso JPA e Hibernate

2. Design Patterns para Persistncia


Acesso a dados um assunto popular entre os desenvolvedores. Sem dvida existem muitas opinies sobre tecnologias especficas de acesso a dados e frameworks de persistncia, respondendo as seguintes perguntas: Qual a melhor maneira de usar essas ferramentas em seu projeto? Que critrios deve-se usar para selecionar a ferramenta certa para seu projeto? O que necessrio conhecer conceitualmente sobre essas ferramentas antes de usar? Se existe muito tempo para escrever sua prpria ferramenta de persistncia?

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: O banco de dados a pedra angular da aplicao e um ativo importante do negcio. O cdigo de acesso a dados e at mesmo o cdigo do aplicativo ou servio so simplesmente mecanismos para conectar o banco de dados com o mundo exterior. Os objetos de negcios na camada intermediria e a interface de usurio ou camada de servio so a aplicao e o banco de dados um meio confivel para manter o estado dos objetos de negcios entre as sesses.

Normalmente que se est trabalhando com objetos de entidade na camada intermediria. De uma forma ou de outra, provavelmente se est fazendo Mapeamento Objeto Relacional (O/RM) para mapear os dados das entidades empresariais para as tabelas do banco de dados e vice-versa. Pode-se realizar este trabalho manualmente, porm mais provvel
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

6 de 28

Curso JPA e Hibernate

com as ferramentas de algum tipo. Essas ferramentas normalmente so grandes e podem potencialmente salvar um monte de tempo de desenvolvimento, mas existem algumas questes que se deve estar ciente, e sempre bom entender como uma ferramenta funciona debaixo das cobertas.

Design Pattern DAO


O padro Data Object Access (DAO) um mecanismo amplamente aceito para abstrair os detalhes de persistncia em um aplicativo. A ideia que em vez da lgica do domnio se comunicar diretamente com o banco de dados, sistema de arquivos, Web Service, ou qualquer mecanismo de persistncia o aplicativo usa, a lgica do domnio fala com uma camada DAO. Esta camada DAO comunica com o sistema de persistncia subjacente ou servio.

A vantagem da camada DAO quando se deseja alterar o mecanismo de persistncia subjacente necessrio somente mudar a camada de DAO, e no todos os lugares da lgica de domnio. A camada DAO geralmente consiste de um conjunto menor de classes, que o nmero de aulas de lgica de domnio que o utiliza. Ao necessitar alterar o que acontece por trs da camada DAO, a operao um pouco menor. tambm uma operao um pouco mais controlada, j que possvel procurar por todas as classes DAO, e verifique se eles so alterados para usar o novo mecanismo de persistncia. Por esta encapsulao do mecanismo de persistncia subjacente a trabalhar, importante que no h detalhes do mecanismo de persistncia subjacente vazar para fora da camada de DAO. Garantir isso , no entanto, um pouco de um desafio, como eu te mostrar no texto ao lado nesta trilha.

Design Pattern PathProxy


um padro de projeto para persistncia de relaes complexas, sem ocupar o seu banco de dados. Use este padro para resolver problemas de muitas entidades cujas inter-relaes so complexas e exigem conhecimento de outros relacionamentos. Criao de objetos explcitos para representar estes tipos de relaes torna-se onerosa. Isto especialmente verdadeiro se os objetos devem ser persistentes, criando uma proliferao de tabelas de banco de dados. Se o projeto do sistema exige um nmero de classes, cuja nica ou principal funo a de modelar as relaes entre outros objetos. Usar PathProxy mais complicado do que usar objetos simples para representar as relaes, por isso deve considerar a sua situao em particular. Se este possui poucos relacionamentos para armazenar e no so muito complicados, PathProxy pode no ser a escolha certa. Por outro lado, uma vez que se alcana um certo nvel de complexidade de relacionamento, usando PathProxy simplifica o seu projeto do sistema global. Ser capaz 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
7 de 28

Curso JPA e Hibernate

reutilizar o mesmo mecanismo e outra vez tambm uma enorme economia de tempo.

Design Pattern Composite


consideradoum padro de particionamento. Descreve que um grupo de objetos sero tratados da mesma forma como uma nica instncia de um objeto. A inteno deste padro "compor" objetos em estruturas de rvore para representar as hierarquias parte todo. Implementar este padro permite que os clientes tratem objetos individuais e composies de maneira uniforme.

Interface Component a abstrao de todos os componentes. declara a interface para os objetos na composio. define opcionalmente uma interface para acessar a classe pai de um componente na estrutura recursiva, e implement-lo se isso for apropriado. representa objetos na composio. implementa todos os mtodos de componentes. representa um componente e seus compostos (componente com filhos). implementa os mtodos para manipular os filhos. implementa todos os mtodos de componentes, geralmente, delegando-os a seus filhos.

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

Curso JPA e Hibernate

3. Mapeamento Objeto Relacional


Caso necessitemos de implementar puramente Orientao a Objetos em um Sistema, devemos decidir qual paradigma de banco de dados utilizaremos para o seu sistema. Atualmente temos as seguintes opes: Sistemas de Bancos de Dados Orientados a Objetos (SGBDOO) Mapeamento Objeto Relacional sobre um banco de dados relacional, ou uma camada de acesso a Banco de Dados Relacional, o que levar a uma camada de objeto chamado de Representao de Negcio.

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.

Atributos de mapeamento para colunas


Um atributo de classe ser mapeado para zero ou um nmero de colunas em um banco de dados relacional. importante lembrar que nem todos os atributos so persistentes. Por exemplo, uma classe NotaFiscal pode ter um atributo total que usado por suas instncias para efeito de clculo, mas que no so salvos no 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

9 de 28

Curso JPA e Hibernate

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:

Classes de mapeamento para as tabelas


Classes so mapeadas para tabelas, embora muitas vezes no diretamente. Exceto com bancos de dados muito simples, quase nunca teremos um mapeamento um para um de classes para tabelas. Vamos discutir algumas estratgias para a implementao de estruturas de herana a um banco de dados relacional: Utilizar uma entidade de dados para uma hierarquia de classe Utilizar uma entidade de dados por classe concreta Utilizar uma entidade de dados por classe

Utilizar uma entidade de dados para uma hierarquia de classe


Com essa abordagem, mapeamos uma hierarquia de classe em uma entidade, onde todos os atributos de todas as classes na hierarquia so armazenadas. A prxima figura representa esse modelo de persistncia para o Diagrama de Classes. Observe que a coluna IDPessoa foi introduzida como chave primria da tabela, utilizaremos OID (Object ID) como identificadores, tambm conhecidos como Chaves Substitutas, em todas as solues, de modo a ser coerente e ter uma melhor abordagem para atribuio de chaves
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

10 de 28

Curso JPA e Hibernate

para as entidades.

As vantagens desta abordagem ser muito simples, o polimorfismo suportado quando ocorre uma troca de papis da entidade Pessoa, para os relatrios ad hoc (listagem realizada para fins especficos de um grupo pequeno de usurios, que normalmente criam seus prprios relatrios) tambm muito fcil com esta abordagem, pois todos os dados pessoais necessrios so encontrados em uma nica Entidade. As desvantagens so: Cada vez que um novo atributo adicionado em qualquer lugar na hierarquia de classe um novo atributo deve ser adicionado tabela. Isso aumenta o acoplamento dentro da hierarquia de classes - se for cometido um erro ao adicionar um nico atributo, que pode afetar todas as classes dentro da hierarquia, para alm das subclasses de qualquer classe tem o novo atributo. Potencialmente desperdia muito espao no banco de dados. Observamos que foi necessrio adicionar a coluna tipoObjeto para indicar se a linha representa um Estudante, um Professor, ou qualquer outro tipo de Pessoa. Isso funciona bem quando algum tem um papel nico, mas rapidamente se decompe se possuem mltiplos papis (por exemplo, a Pessoa um Estudante e um Professor).

Utilizar uma entidade de dados por classe concreta


Com esta abordagem, cada entidade inclui os atributos e os atributos herdados da classe que representa. A prxima figura representa esse modelo de persistncia para o Diagrama de Classes. Existem dados das entidades correspondentes de ambas classes Estudante e Professor, porque so uma extenso, mas no para a classe Pessoa porque a superclasse (indicada pelo nome). A cada uma das entidades foi atribudo uma chave primria prpria IDEstudante e IDProfessor respectivamente.

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

Curso JPA e Hibernate

As desvantagens so: Ao modificar uma classe deve-se modificar a entidade e a entidade de qualquer uma de suas subclasses. Por exemplo, ao adicionar a altura e peso para a classe Pessoa, necessrio atualizar em ambas as tabelas. 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?

Utilizar uma entidade de dados por classe


Com essa abordagem, criamos uma entidade por classe, os atributos que so o OID e os atributos so especficos para essa classe. A prxima figura representa esse modelo de persistncia para o Diagrama de Classes. Notamos que o campo IDPessoa utilizado como chave primria para as trs entidades. A coluna IDPessoa nas entidades Professor e Estudante atribudo como dois esteretipos, algo que no permitido para a UML ( Unified Modeling Language).

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

Curso JPA e Hibernate

operar de forma independente). Relatrios ad hoc em seu banco de dados difcil, a menos que seja adicionado vises para simular as tabelas desejadas.

Mapeando Associaes, Agregao e Composio


No se deve mapear somente os objetos no banco de dados, como tambm mapear as relaes que o objeto est envolvido como possam ser restaurados em uma data posterior. Existem quatro tipos de relaes que um objeto pode ser envolvidos: Herana, Associao, Agregao e Composio. Para mapear essas relaes de forma eficaz, devemos entender as diferenas entre elas, como implementar relacionamentos em geral, e como implementar especificamente os relacionamentos muitos para muitos. De uma perspectiva do banco de dados, a nica diferena entre as relaes de Associao, Agregao e Composio quo firmemente os objetos so ligados um ao outro. Com a Agregao e Composio, tudo o que realizamos no banco de dados necessrio a ser realizado para as partes, enquanto que com a Associao este no o caso.

Relaes de aplicao em bancos de dados relacionais


Relaes em bases de dados relacionais so mantidas atravs da utilizao de chaves estrangeiras. Uma chave externa um ou mais atributos de dados que aparecem em uma entidade que pode ser parte de, ou coincidente com, a chave de outra entidade. As chaves estrangeiras permitem relacionar uma linha em uma entidade com uma linha em outra. Para implementar relacionamentos um para um e um para muitos que s tem que incluir a chave de uma entidade em outra entidade.

Implementar relacionamentos muitos para muitos


necessrio o conceito de uma tabela associativa, uma entidade de dados, cujo nico propsito manter uma associao entre duas ou mais tabelas em um banco de dados relacional. Na figura seguinte veremos uma relao de muitos para muitos entre as entidades Funcionrio e Benefcio.

Na bases de dados relacionais os atributos esto contidos numa tabela associativa e so tradicionalmente a combinao das chaves nas tabelas envolvidas na relao. O nome de uma tabela associativa tipicamente a combinao dos nomes das tabelas que associa ou o nome da associao que implementa.

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

Curso JPA e Hibernate

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.

Estrutura de consulta JPQL


A sintaxe da linguagem JPQL muito semelhante sintaxe SQL. Ter um SQL como sintaxe em consultas JPA uma vantagem importante, pois o SQL uma linguagem de consulta muito poderosa e muitos desenvolvedores j esto familiarizados. A principal diferena entre SQL e JPQL que o resultado de uma consulta SQL so registros e campos, ao passo que o resultado de uma consulta JPQL classes e objetos. Por exemplo, uma consulta JPQL pode recuperar e retornar objetos de entidade, em vez de apenas os valores de campo a partir de tabelas de banco de dados, como acontece com SQL. Isso faz objecto JPQL mais orientado amigvel e fcil de usar em Java. Tal como acontece com SQL, uma consulta JPQL SELECT tambm composto por at 6 clusulas no seguinte formato:
SELECT [WHERE [GROUP [ORDER ... FROM ... ...] BY ... [HAVING ...]] BY ...]

As duas primeiras clusulas, SELECT e FROM so necessrios em cada consulta de recuperao (atualizar e excluir tm uma forma ligeiramente diferente). As outras clusulas JPQL, onde, GROUP BY, HAVING e ORDER BY so opcionais. A estrutura JPQL para excluir e modificar mais simples:
DELETE FROM ... [WHERE ...] UPDATE ... SET ... [WHERE ...]

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

Curso JPA e Hibernate

As poucas excees em que JPQL diferencia maisculas de minsculas incluem elementos de origem principalmente Java, como nomes de classes de entidade e campos persistentes, que so sensveis ao caso. Alm disso, strings tambm so maisculas de minsculas (por exemplo, "ORM" e "orm" so valores diferentes).

Uma consulta minima JPQL


A consulta seguinte recupera todos os objetos de Pas no banco de dados:
SELECT p FROM Pais AS p

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 Pessoa que possuem o estado civil casado ou divorciado:


SELECT p FROM Pessoa p JOIN p.estadocivil e WHERE e.descricao IN ("casado","divorciado")

Retornar objetos de Pessoa por uma determinada lista de enumeraes:


SELECT p FROM Pessoa WHERE p.enum = x25.com.tutorial.enum.value

Retornar objetos de Autor por ordem alfabtica de Nome


SELECT a FROM Autor a ORDER BY a.nome

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

Curso JPA e Hibernate

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.

Construindo uma consulta Criteria


A interface CriteriaBuilder o padro Abstract Factory para CriteriaQuery. Um CriteriaBuilder obtido a partir de qualquer um EntityManagerFactory ou um EntityManager como por exemplo:
EntityManager em = factory.createEntityManager(); CriteriaBuilder queryBuilder = em.getCriteriaBuilder(); CriteriaQuery qdef = queryBuilder.createQuery();

O primeiro passo na construo de uma definio de consulta a especificao de um objeto de Root. Este objeto responsvel por especificar os objetos de domnio em que a consulta avaliada, sendo uma instncia da interface Root <T>. adicionada a uma CriteriaQuery pela chamada ao mtodo addRoot().
Root<Cliente> cliente = qdef.from(Cliente.class);

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));

onde Cliente_.ordens representa um campo de classe metamodelo para o Cliente. Essas classes de metamodelo so geradas durante a compilao, processando a anotao persistente no cdigo fonte de Cliente.java. A condio de uma definio de consulta definido atravs do mtodo where() onde o argumento designa um predicado condicional. Predicados condicionais so frequentemente compostos de um ou mais comparaes entre os valores dos atributos dos objetos de domnio e algumas variveis. Por exemplo, para selecionar o Cliente cujo nome "Fernando Anselmo" e tem pedidos que ainda no foram entregues, podemos construir o predicado e configur-lo para a definio da consulta como:
qdef.where(cliente.get(Cliente_.nome).equal("Fernando Anselmo") .and(os.get(OrdemServico_.status).equal(OrdemStatus.ENTREGADO).not()));
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

16 de 28

Curso JPA e Hibernate

O mtodo select() define o resultado da consulta. Se deixado sem especificao, o resultado da seleo assumido como sendo um objeto do domnio raiz. No entanto, podemos especificar as projees selecionadas explicitamente como uma lista:
qdef.select(cliente.get(Cliente_.name), os.get(OrdemServico_.status));

Um atributo de um objeto de domnio tambm pode ser especificado atravs da navegao via get(). O atributo se refere a uma propriedade vlida persistente do objeto de domnio recebe, no entanto, a validao que no seja executada durante a construo da definio da consulta. Toda validao adiada at que a consulta seja realmente executada. Por outro lado, usando o metamodelo para o caminho da navegao refora a verificao de tipo.

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

Curso JPA e Hibernate

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. Tipo seguro para o grupo de validao Validao do modelo Validao da gravidade consciente Validao do cliente Ordenar mensagens de violao Apoio a injeo de dependncia para os validadores de restrio Fonte de restrio mapeada (por exemplo, usar DTO com BV) Suporte a anotao @Valid

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

Curso JPA e Hibernate

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

Curso JPA e Hibernate

7. SQL Nativo
JPA pode executar consultas SQL simples. Esse tipo de Consulta denominada JPA Native Query e possui as seguintes propriedades: Uma Native Query retorna um nico valor escalar Retorna todos os valores persistentes de classe de entidade especificada.

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`) )

Modelo Classe: Estudante.java


package x25.com.tutorial; import import import import import import import 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

Curso JPA e Hibernate

public String getNome() { return nome; } public void setNome(String nome) { this.nome = nome; } public String getCurso() { return curso; } public void setCurso(String curso) { this.curso = curso; }

Classe Principal: JPANativeQuery.java


package x25.com.tutorial; import import import import import import import java.util.Iterator; java.util.List; javax.persistence.EntityManager; javax.persistence.EntityManagerFactory; javax.persistence.EntityTransaction; javax.persistence.Persistence; javax.persistence.Query;

public class JPANativeQuery { public static void main(String[] args) { EntityManagerFactory emf = Persistence.createEntityManagerFactory("jpa"); EntityManager em = emf.createEntityManager(); try { EntityTransaction entr = em.getTransaction(); entr.begin(); Query query = em.createNativeQuery("SELECT nome FROM estudante"); List stList = query.getResultList(); Iterator stIterator = stList.iterator(); while (stIterator.hasNext()){ System.out.println("Nome: " + stIterator.next()); } entr.commit(); } finally { em.close(); } } }

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

Curso JPA e Hibernate

8. Recursos Avanados: Cache e Locks


JPA possui um cache opcional de dados de objetos persistentes que opera no nvel da classe EntityManagerFactory. Esse cache projetado para aumentar significativamente o desempenho, permanecendo em total conformidade com o padro JPA. Isto significa que ligar a opo de cache transparente pode aumentar o desempenho de sua aplicao, sem alteraes em seu cdigo.

O Gerenciador de Entidade garante que dentro de um contexto de persistncia nica, para qualquer linha de banco de dados particular, haver uma instncia do objeto. No entanto, a mesma entidade pode ser controlada na transao de outro usurio, ento deve-se usar um bloqueio otimista ou pessimista.

O cache de dados do JPA no relacionado ao cache da EntityManager ditada pela especificao da JPA. A especificao da JPA possui um comportamento para o cache do EntityManager que visa garantir isolamento de transao, quando operando em objetos persistentes. projetado para proporcionar aumentos significativos de desempenho sobre a
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
22 de 28

Curso JPA e Hibernate

operao cacheless, garantindo que o comportamento ser idntico tanto na operao de cache habilitado e cacheless.

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;

O atributo verso incrementado com uma confirmao bem-sucedida. O atributo verso pode ser um tipo int, short, long ou timestamp. Isto resulta no seguinte SQL:
UPDATE Employee SET ..., version = version + 1 WHERE id = ? AND version = readVersion

As vantagens do bloqueio otimista que no h bloqueios na base de dados e so realizadas para dar uma melhor escalabilidade. As desvantagens so que o usurio ou aplicao deve atualizar e tentar novamente com as atualizaes que falharam.

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]

O bloqueio pessimista assegura que as operaes no atualizam a mesma entidade, ao mesmo tempo, que pode simplificar cdigo de aplicao, mas limita o acesso simultneo aos dados que podem causar uma mau escalabilidade e bloqueios. melhor para aplicaes com maior risco de discrdia entre transaes concorrentes. Os trade-offs so utilizados para segurar bloqueios maiores, os riscos de escalabilidade ruim e impasses. Quanto mais tarde for executado um lock, maior o risco de dados desatualizados, que pode causar uma exceo do bloqueio otimista, se a entidade foi atualizado aps a leitura, mas antes de bloquear.

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

Curso JPA e Hibernate

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"); }

Este cdigo obtm um objeto de javax.persistence.EntityManagerFactory. Observe a utilizao de org.hibernate.tutorial.jpa como o nome unidade de persistncia, que corresponde a partir do exemplo "persistence.xml". Exemplo para salvar:
EntityManager entityManager = entityManagerFactory.createEntityManager(); entityManager.getTransaction().begin(); entityManager.persist(new Event("Este um primeiro evento", new Date())); entityManager.persist(new Event("O prximo evento", new Date())); entityManager.getTransaction().commit(); entityManager.close();

Aqui usamos um javax.persistence.EntityManager em oposio a um org.hibernate.Session. JPA chama o mtodo persist(), em vez de insert(). Obter uma listagem:
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
24 de 28

Curso JPA e Hibernate

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

Curso JPA e Hibernate

10. Erros Comuns


Para os dados relacionais de persistncia do Hibernate certamente a soluo mais popular no mercado. Tem sido em torno de anos e provavelmente sido usado em milhares de projetos. Com a sua mais recente verso, mesmo em conformidade com a especificao JPA. Ento, com Hibernate oferecendo tudo por que utilizar outra coisa? Bem, pensamos que o Hibernate e a JPA no so um par simplesmente to perfeito quanto parece. Para explicar o porqu, queremos oferecer-lhe algumas razes que achamos que pode estar errado.

Dados modelo de definio: O problema com os metadados


Para trabalhar cada soluo de persistncia de dados relacionais precisamos entender o modelo de dados subjacente. Hibernate oferece duas formas para definir o modelo de dados: arquivos de mapeamento XML e anotaes. Anotaes s recentemente foram introduzidas para simplificar o mapeamento objeto relacional e h uma abundncia de razes pelas quais as anotaes so claramente a melhor soluo sobre mapeamento XML. Assim no vamos considerar o mapeamento XML mais longe e concentrar-se em anotaes. No entanto, tudo que dito aqui anotaes sobre aplica-se a XML de mapeamento de uma forma similar. Os metadados fornecidos com anotaes exigido pelo Hibernate para saber onde e como persistir objetos no banco de dados. Esta informao, contudo, no pode apenas ser til para o Hibernate, mas tambm para a lgica do aplicativo e assim pode-se querer acessar a partir do seu cdigo em vez de redundante fornecer as mesmas informaes novamente. Um bom exemplo , o comprimento mximo de um campo de texto ou se ou no um campo obrigatrio. Em uma interface de usurio, por exemplo, podemos necessitar desta informao para a exibio de um controle de entrada de formulrio ou para validao. Com as anotaes possvel acessar essas informaes de seu cdigo, mas uma propriedade de anotao particular no pode ser diretamente relacionado a partir do cdigo.

Dados definio do objeto: A mania Setter e Getter


Alm de metadados tambm precisamos de um lugar para armazenar e acessar os dados. Para Hibernate e JPA este um JavaBean ou POJO que est equipado com um campo de membro, bem como um absorvente e um mtodo no padro SET para cada uma das colunas da tabela correspondente. Para os modelos de dados grandes, isso significa lotes de linhas de cdigo. Ferramentas do Hibernate pode ser usado para gerar automaticamente todo este cdigo usando engenharia reversa. No entanto, para projetos grandes e maduros podemos executar o problema que depois de ter alterado manualmente um bean ou cdigo de mapeamento - e manter essa mudana - ferramentas automticas so problemticas. Ento, muitas vezes todo este cdigo, incluindo os metadados so mantidos mo. Ainda pior, uma vez que estes objetos so geralmente utilizados como objetos de transferncia 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

26 de 28

Curso JPA e Hibernate

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. provvel que, ao crescer o projeto, precisamos substituir novos mtodos existentes implement-los.

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.

Usar a identidade do aplicativo pode causar um comportamento estranho


A causa mais comum de problemas como estes quando usando a identidade do aplicativo a falha para a classe identidade do aplicativo para substituir os mtodos corretamente os mtodos equals() e hashCode() para que os objetos de identidade com equivalentes valores de chave primria so considerados iguais.

Erros de conexo ao retornar instncias persistentes de um Session Bean


Uma causa comum desse problema devido ao continer EJB, serializao nos casos que so retornados do EJB. O processo de serializao acontece em um momento no ciclo de vida do EJB, onde o atual status da transao est indefinida. A serializao pode resultar em relaes descarregados sendo percorridos, tentado obter uma conexo JDBC para realizar a travessia, e o servidor de aplicativo pode ento proibir o acesso de conexo devido a um status de transao invlida. A soluo mais simples para isso fazer o objeto ser devolvido de forma transitria, ou retornar uma instncia individual, ou executar manualmente a serializao antes de retornar a partir do mtodo EJB.

Relaes se perdem aps um Commit


O problema pode ser a definio de uma relao bidirecional, mas no definir ambos os
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
27 de 28

Curso JPA e Hibernate

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