JPA com Hibernate

Rascunho
Autor:Ivan Salvadori
1. Introduo ao JPA com Hibernate.
JPA ou Java Persistence API, uma padronizao da linuaem Java, para mapeamento
ob!eto"relacional# $m outras palavras, a padronizao de um mecanismo capaz de armazenar no
banco de dados as classes do modelo da aplicao %ue necessitam de persist&ncia# $ste mecanismo
visa promover todos os recursos de banco de dados, sem a necessidade de manipulao direta de
instru'es S()#
Hibernate um *rame+or, %ue implementa a especi*icao do JPA# - o verdadeiro
respons.vel pela e/ecuo do mecanismo de persist&ncia de dados# JPA de*ine as reras en%uanto o
Hibernate as e/ecuta# $/istem v.rias outras implementa'es do JPA, como o 0op)in, da 1racle#
$ssas implementa'es so tambm so chamadas de Provider, 2 Provedor 3#
Para mostrar realmente o ob!etivo do JPA, imaine o seuinte cen.rio:
Desejo gravar no banco de dados informaes de cadastros dos meus clientes.
A *orma tradicional de manipulao de banco de dados em Java trabalha diretamente com
criao de cone/'es, elaborao de instru'es S(), atribuio de valores a estas instru'es seuido
da e/ecuo das %uer4s#
Para inserir um cliente, uma classe respons.vel pela manipulao do banco, eralmente um
5A1, recebe o ob!eto do tipo 6liente, com as in*orma'es dese!adas !. de*inidas no ob!eto# 5e
posse desse ob!eto, as in*orma'es so e/tra7das atravs dos mtodos getter's, e inseridas na
instruo S() de I8S$R0#
String comando = "insert into Cliente (nome, cpf, rg, telefone ,data_nasc)
values (?, ?, ?, ?, ?)";
Ilustrao 9: 6lasse 6liente#
Ilustrao :: ;ecanismo 0radicional de <ravao#
1 trecho de c=dio abai/o mostra a *orma tradicional de ravao de in*orma'es dos
clientes no banco de dados ;4S%l#
java.sql.Connection con;

try
con = !river"anager.getConnection("jd#c$m%sql$&&local'ost$(()*&#ase", "user","sen'a");
+ catch(S,-./ception e)
throw new 0untime./ception(e);
+
String comando = "insert into Cliente (nome, data_nasc, telefone, rg, cpf)
values (?,?,?,?,?)";

1reparedStatement stmt;
try
stmt = con.prepareStatement(comando);
stmt.setString(2, cliente.getNome() );
stmt.set!ate(3, new
java.sql.!ate(cliente.getDataNasc().get4ime() ) ); &&formata data para sql

stmt.setString((, cliente.getTelefone() );
stmt.setString(5, cliente.getRg() );
stmt.setString(6, cliente.getCpf() );

stmt.e/ecute();
stmt.close();
con.close();
+ catch (S,-./ception e)
e.printStac74race();
+
Para listar os clientes ravados o banco, e/ecuta>se um instruo S() S$)$60, com os
dados obtidos do banco constru7do um ob!eto do tipo 6liente, e de*inido as suas propriedades
atravs dos mtodos setter's#
1reparedStatement stmt = con.prepareStatement("select 8 from Cliente");
while (rs.ne/t())
Cliente c = new Cliente();
c.setCodigo(rs.get9nt("codigo"));
c.setNome(rs.getString("nome"));
c.setRg(rs.getString("rg"));
c.setCpf(rs.getString("cpf"));
c.setTelefone(rs.getString("telefone"));
c.setDataNasc( rs.get!ate("data_nasc") );
+
Ilustrao ?: ;ecanismo 0radicional de Seleo#
Analisando os mecanismos e c=dios ilustrados anteriormente, nota>se %ue para implementar um
sistema de mdio a rande porte, uma es*oro consideravelmente rande se *az necess.rio para
tratar os assuntos de manipulao do banco de dados, observa>se tambm %ue as classes com essas
responsabilidades so e/tensas, %ual%uer alterao no banco de dados implica em manuteno do
c=dio#
JPA se prop'em a *acilitar esse trabalho, abstraindo os detalhes do banco de dados e
concentrando>se nas suas *un'es# Imaine aora ravar o mesmo ob!eto cliente citado no es%uema
anterior, mas aora sem se preocupar com os detalhes *7sicos da tabelas, nome dos campos,
convers'es de tipos dentre outros detalhes# 1 trecho de c=dio abai/o mostra como seria o processo
de ravao no banco de dados utilizando o JPA com Hibernate#
public void gravar(Cliente cliente)
'i#ernate.gravar(cliente);
+
;ecanismo de procura por um determinado cliente a partir do seu c=dio:
public Cliente procurar(int codigo)
return 'i#ernate.procurar(Cliente.class, codigo);
+
)embrando %ue os c=dios acima apenas demonstram a *iloso*ia do mecanismo utilizado
pelo JPA, em um caso real, um pouco mais de c=dio necess.rio#
6om os e/emplos anteriores, pode>se notar %ue toda a implementao da persist&ncia dos
dados *ica sob responsabilidade do @rameAor,, retirando toda a manipulao direta com o banco
de dados# 6aso aluma alterao se!a *eita na classe 6liente, %ue conse%uentemente provo%ue
aluma alterao na tabela %ue armazena seus dados, nenhum c=dio so*rer. alterao, diminuindo
muito o custo de manuteno# Isso poss7vel pois o JPA com Hibernate representa uma camada
e/tra entre a aplicao e o J5B6, at ento proramado diretamente pelo desenvolvedor#
JPA nos possibilita desenvolver toda a persist&ncia com o m7nimo de c=dio poss7vel atravs
de uma *orma *ant.stica, mas como poss7vel realizar essa *acilidadeC Ser. o Assunto dos
pr=/imos cap7tulos#
Ilustrao D: $strutura JPA E Hibernate # Adaptado de Bellia, Renato#
Revista Java ;aazine, ed# DD, p# :F#
Banco de 5ados
Aplicao
JPA
Hibernate
J5B6
. !ntendendo o "rame#or$.
Seundo @)GHI1 H$8RI(I$ 6IR0$, Antares In*ormation S4stems:
A ideia da persist&ncia 1"R reunir as vantaens de se utilizar um modelo orientado a
ob!etos para a construo de uma aplicao, com a per*ormance e a con*iabilidade dos bancos de
dados relacionais# 2adaptado de JPA: Persist&ncia padronizada em Java3#
1 modelo orientado a ob!etos nos d. muito mais recursos para a representao da
in*ormao, *ica muito mais *.cil de entender e principalmente desenvolver so*t+are *azendo uso
do paradima dos ob!etos, por outro lado, o modelo relacional e/celente para armazenamento
*7sico das in*orma'es# 6riou>se ai um empasse, sendo necess.rio uma especie de traduo entre um
modelo para o outro# A introduo desse material e/empli*icou a *orma %ue essa JtraduoK
realizada via J5B6# A $speci*icao JPA possibilita trabalhar com o modelo relacional dos bancos
de dados, com a representao do modelo orientado a ob!etos# 1bserve o c=dio a seuir:
public void gravar(Cliente cliente)
'i#ernate.gravar(cliente);
+
6omo poss7vel o *rame+or, Hibernate realizar a ravao das in*orma'es do ob!eto
cliente no banco de dadosC
Para %ue isso se!a poss7vel, o Hibernate deve ter conhecimento das in*orma'es do ob!eto
cliente, assim como conhecer os detalhes do banco de dados# - necess.rio o conhecimento do
conteLdo das tabelas dentre outras in*orma'es liadas ao pro!eto relacional#
Hamos recorrer ao nosso problema de cadastro de clientes, temos a nossa 6lasse 6liente %ue
deve ter as suas propriedades ravadas# A tabela 6liente da suporte para a ravao de todas as
in*orma'es da classe# 5essa *orma a classe cliente ser. armazenada na tabela 6liente# 6ada
atributo da classe ser. ravado em uma coluna da tabela com seu respectivo nome# A Ilustrao M
demonstra como deve ser o mapeamento da classe 6liente para a tabela 6liente#
Ilustrao 5: Mapeamento classe Cliente para a tabela Cliente.
A con*iurao do Hibernate envolve a especi*icao deste mapeamento, de*inido %uais
atributos sero ravados em cada campo de uma tabela no banco de dados# $ssa con*iurao se *az
por meio de anota'es# Anota'es so instru'es %ue descrevem in*orma'es sobre a classe# Hamos
um e/emplo pr.tico# 1 c=dio abai/o mostra a classe 6liente, totalmente anotada, trazendo as
in*orma'es %ue o *rame+or, necessita para realizar o mapeamento para a tabela do banco de
dados %ue ir. armazen.>la#
:.ntit%
:4a#le(name = "Cliente")
public class Cliente implements Seriali;a#le
:9d
:<enerated=alue(strateg%=<eneration4%pe.IDENTITY)
:Column(unique=true, nulla#le=false)
private int codigo;
:Column(lengt'=56)
private String cpf;
:Column(lengt'=56)
private String rg;
:Column(lengt'=56)
private String nome;
:Column(lengt'=56)
private String telefone;
:Column(name = "data_nasc")
:4emporal(4emporal4%pe.DATE)
private !ate data>ascimento;
set?s()
get?s()
+
Repare a presena de estruturas %ue iniciam com J N K, so as anota'es# $/iste di*erentes
tipos de anota'es, cada uma denota uma con*iurao di*erente, de*inido in*orma'es a
componentes %ue a procedem, vamos e/plicar alumas:
%!ntit& > $sta anotao diz %ue essa classe uma entidade, portanto ser. persistida# 2 uma
classe chamada de entidade %uando caracterizar necessidade de ravao no banco de dados de
suas propriedades 3#
%'able2name = "Cliente"3 E Anotao respons.vel por apontar em %ual tabela a classe ser.
armazenada, neste caso na tabela 6liente#
%Id > 5e*ine o identi*icador Lnico da entidade, ser. a chave prim.ria da tabela#
%(enerated)alue2strateg%=<eneration4%pe.IDENTITY3 E 6=dio auto increment.vel#
%*olumn2unique=true, nulla#le=false3 E 5iz %ue o atributo ser. ravado na coluna
especi*icada# 6aso no se!a in*ormado um nome, a coluna assume o mesmo nome do atributo# As
op'es de 2uni%ueOtrue, nullableO*alse3 in*ormam %ue o c=dio Lnico e no aceita valores nulos#
%*olumn(name = "data_nasc") E 5e*ine um nome da coluna da tabela di*erente do nome
do atributo da classe# 1 atributo data+ascimento ser. ravado na coluna data,nasc#
%'em-oral(4emporal4%pe.DATE) @ Anotao %ue indica %ue o tipo de atributo uma data
e ser. armazenado com essa caracter7stica#
6om as anota'es anteriores a instruo J hibernate#ravar2cliente3P K aora parece
totalmente poss7vel de acontecer, pois a classe 6liente possui todas as in*orma'es re*erentes a sua
ravao no banco# A con*iurao re%uer ainda as in*orma'es para realizar a cone/o com o
banco de dados, como por e/emplo endereo ip do servidor, usu.rio e senha# H. um ar%uivo
especi*ico destinado a uardar essa con*iurao, -ersistence..ml# A listaem a seuir mostra um
e/emplo dessa con*iurao#
A?/ml version="1.0" encoding="UTF-8"?B
Apersistence version="1.0"
/mlns="http://java.sn.co!/"!#/ns/pe$sistence"
/mlns$/si="http://&&&.&'.o$g/(001/)*+,che!a-instance"
/si$sc'ema-ocation="http://java.sn.co!/"!#/ns/pe$sistence
http://java.sn.co!/"!#/ns/pe$sistence/pe$sistence-1-0."s."B
ApersistenceCunit name="C#iente/0A"B
AclassBClienteA&classB
ApropertiesB
Apropert% name="hi1e$nate..ia#ect"
value="o$g.hi1e$nate..ia#ect.*2,3+4InnoD5Dia#ect" &B
Apropert% name="hi1e$nate.connection..$ive$-c#ass"
value="o$g.gjt.!!.!2s6#.D$ive$" &B
Apropert% name="hi1e$nate.connection.$#"
value="j.1c:!2s6#://#oca#host/no!eDa5ase" &B
Apropert% name="hi1e$nate.connection.se$na!e" value="sa$io" &B
Apropert% name="hi1e$nate.connection.pass&o$." value="senha" &B
A&propertiesB
A&persistenceCunitB
A&persistenceB
Alumas considera'es sobre a listaem anterior:
AclassBClienteA&classB > 6lasse a ser erenciada pelo JPA#
ApersistenceCunit name="C#iente/0A"B > 8uma solicitao de servios do JPA, uma
cone/o ser. criada utilizando um persistence>unit, identi*icado atravs de seu nome, onde as
in*orma'es necess.rias para a estabelecer uma cone/o com o banco esto presentes#
As clausulas propert% in*ormam os detalhes da cone/o, identi*icando o tipo de banco de
dados utilizado, endereo do servidor, senha, usu.rio dentre outras in*orma'es#
1utro conceito %ue o JPA nos apresenta o $ntit4;anaer, respons.vel pela e/ecuo dos
servios de persist&ncia do *rame+or,# $le erencia as entidades, estabelece a cone/o com o banco
de dados, e/ecuta as opera'es de ravao, alterao, remoo e seleo das classes anotadas# 1
$ntit4;anaer criado baseando>se em no persistenceCunit de*inido no persistence#/ml# 1
c=dio %ue seue, demostra a criao do erenciador#
.ntit%"anagerDactor% emf = 1ersistence.c$eateEntit2*anage$Facto$2("Cliente!"");
.ntit%"anager em = emf.create.ntit%"anager();
Repare %ue o parametro de contruao do erenciador o mesmo nome contido no valor
name da unidade de persistencia#
ApersistenceCunit name="ClienteJPA"B
8os e/emplos anteriores, tratamos apenas a *iloso*ia de *uncionamento do Hibernate, o
e/emplo a seuir mostra o c=dio %ue realiza a ravao de um ob!eto cliente, no banco de dados,
mas dessa vez utilizando a sinta/e completa do JPA#
.ntit%"anagerDactor% emf = 1ersistence.c$eateEntit2*anage$Facto$2("Cliente!"");
.ntit%"anager em = emf.create.ntit%"anager();
em.get4ransaction().#egin();
em.persist(cliente);
em.get4ransaction().commit();
em.close();
emf.close();
1 e/emplo cria um $ntit4;anaer, *azendo re*er&ncia ao persistence#unit con*iurado no
ar%uivo persistence#/ml, em seuida uma transao iniciada#
em.get4ransaction().#egin();
A instruo abai/o diz ao $ntit4;anaer para e/ecutar a ravao, no banco de dados, do
ob!eto cliente passado por parQmetro# Persist sini*ica persistir, armazenar, ravar#
em.persist(cliente);
Para %ue o ob!eto se!a realmente ravado, deve>se dar a ordem de e/ucao de ravao,
isso se *az atravs do c=dio abai/o# *ommit concretiza a solicitao do recurso de ravao#
em.get4ransaction().commit();
Para *inalizar, encerra>se a transao#
em.close();
emf.close();
Para realizar uma seleo, o mecanismo similar, vamos a um e/emplo de procura de um
cliente a partir do seu c=dio:
em.get4ransaction().#egin();
compra = em.find(Compra.class, codigo);
em.get4ransaction().commit();
8o e/emplo acima, uma transao iniciada, e o mtodo find localiza a partir do c=dio o
ob!eto, os dois parQmetros da procura so a classe do ob!eto, %ue serve de re*erencia para dizer
aonde procurar, e o c=dio, %ue diz o%ue procurar#
1 c=dio abai/o mostra como alterar os ob!etos:
entit%"anager.merge(cliente);
1 mtodo merge atualiza o reistro da tabela do banco %ue possui o mesmo c=dio do
ob!eto passado por parQmetro# As ilustra'es R e S mostram o processo de atualizao do ob!eto
cliente#
Cliente cliente = new Cliente();
cliente.set>ome("EosF Serra");
cliente.set0g("23(");
cliente.setCpf("56*");
cliente.set4elefone("GGG");
cliente.setCodigo(6);
em.get4ransaction().#egin();
em$merge(cliente);
em.get4ransaction().commit();
1 e/emplo anterior altera os valores do cp*, r e tele*one do reistro de c=dio M# Repare
%ue a data de nascimento no *oi de*inida no ob!eto cliente alterado, sendo assim, o atributo alterou
o valor armazenado na tabela por valores nulos# Para %ue ocorra a alterao necess.rio %ue o
c=dio do cliente esta de*inido no ob!eto passado por parQmetro#
Aora vamos remover o reistro %ue *oi alterado no e/emplo anterior, seuindo o principio
dos e/emplos temos:
Cliente cliente = new Cliente();
cliente.set>ome("EosF Serra");
cliente.set0g("23(");
cliente.setCpf("56*");
cliente.set4elefone("GGG");
cliente.setCodigo(6);
em.get4ransaction().#egin();
em.remove(cliente);
em.get4ransaction().commit();
Recebemos o seuinte erro:
./ception in t'read "main" java.lang.9llegalHrgument./ception$
0emoving a detac'ed instance Cliente
Ilustrao R: Reistro antes da alterao#
Ilustrao S: Reistro depois da alterao#
Para e/plicar o%ue ocorreu errado na tentativa de remover o reistro, tem>se %ue entender o
conceito de entidades erenciadas pelo JPA# Ao criar ob!etos na aplicao, inicialmente esses no
esto sendo erenciados pelo JPA#
Ao e/ecutar opera'es de persist&ncia, como por e/emplo -ersist, a entidade ravada no
banco de dados e passa a ser erenciada pelo *rame+or,#
8a tentativa de remoo, %ue resultou no erro, tinha>se o seuinte cen.rio:
Ilustrao F : $ntidades no erenciadas pelo JPA#
$ntidades ;onitoradas pelo JPA
Cliente titi = new Cliente();
cliente$setNome(%Carvo%);
cliente$setCpf(%&&&'())#'%);
cliente$setRg(%&)*'+&**%);
cliente$setTelefone(%&)++,,,%);
Cliente bi = new Cliente();
cliente$setNome(%bianchi%);
cliente$setCpf(%'&++'+'%);
cliente$setRg(%+&',-&'&%);
cliente$setTelefone(%&)+.++%);
Ilustrao T: Processo de erenciamento de entidades JPA#
$ntidades ;onitoradas pelo JPA
Cliente carvo = new Cliente();
cliente$setNome(%Carvo%);
cliente$setCpf(%&&&'())#'%);
cliente$setRg(%&)*'+&**%);
cliente$setTelefone(%&)++,,,%); Cliente bi = new Cliente();
cliente$setNome(%bianchi%);
cliente$setCpf(%'&++'+'%);
cliente$setRg(%+&',-&'&%);
cliente$setTelefone(%&)+.++%);
em$getTransaction()$begin();
em$persist(cliente);
em$getTransaction()$commit();
Ilustrao 9U : 0entativa de remoo de entidade no erenciada#
Cliente cliente = new Cliente();
cliente$setNome(%os/ 0erra%);
cliente$setRg(%1.+%);
cliente$setCpf(%&',%);
cliente$setTelefone(%(((%);
cliente$setCodigo(');
em.getTransaction().begin();
em.remove(cliente);
em.getTransaction().commit();
$ntidades ;onitoradas pelo JPA
$RR1
8ote %ue a remoo se aplicou a uma entidade %ue no estava sendo erenciada pelo JPA, este o
motivo do erro# 1 JPA no pode remover uma entidade %ue no erenciada por ele# Sendo assim, a
entidade %ue dese!a>se remover deve estar sob o dom7nio do *rame+or,# Ima *orma de *azer isso
solicitar %ue o Hibernate *aa a pes%uisa da entidade# 0oda a entidade selecionada do banco de
dados atravs do *rame+or,, est. sob erenciamento# 1 c=dio %ue seue mostra a implementao
da soluo encontrada#
.ntit%"anagerDactor% emf = 1ersistence.c$eateEntit2*anage$Facto$2("E1H./emplo");
.ntit%"anager em = emf.create.ntit%"anager();
em.get4ransaction().#egin();
Cliente c = em.find(Cliente.class, 6);
em.get4ransaction().commit();
em.get4ransaction().#egin();
em.remove(c);
em.get4ransaction().commit();
em.close();
emf.close();
/esumo do *a-0tulo1
A *orma tradicional de manipulao de in*orma'es em banco de dados, envolve um c=dio
muito e/tenso e propenso a erros e pro*undas modi*ica'es caso se!a necess.rio %ual%uer
modi*icao na con*iurao dos dados# A pratica de uso J5B6 despende de rande es*oro para o
desenvolvimento e conse%uentemente na manuteno dos sistemas#
JPA vem com a proposta de *acilitar o penoso trabalho de manipular in*orma'es %ue
precisam ser ravadas em banco de dados, tornando a manipulao de banco de dados, %ue seue o
paradima relacional, em uma abordaem orientada a ob!eto#
1 Hibernate uma implementao da especi*icao padro, e a con*iurao do *rame+or,
se *az principalmente por meio de anota'es nas classes %ue so*reram persist&ncia# As
con*iura'es *7sicas do banco de dados *icam no ar%uivo persistence#/ml, %ue contm todas as
propriedades do sistema erenciador de banco de dados a a ser utilizado#
As *un'es de manipulao de dados so realizadas por mtodos do erenciador de
entidades, sendo essas -ersist, merge, find e remove# 1 JPA mantem sob seu erenciamento as
entidades %ue manipula#
$ste capitulo mostrou os conceitos b.sicos do JPA com Hibernate, seus principais
componentes, conceitos e con*iura'es#
Ilustrao 99: Remoo de entidade erenciada#
em.get4ransaction().#egin();
Cliente c = em.find(Cliente.class, 6);
em.get4ransaction().commit();
em.get4ransaction().#egin();
em.remove(c);
em.get4ransaction().commit();
$ntidades ;onitoradas pelo JPA
>ome = ("EosF Serra");
0g = ("23(");
Cpf = ("56*");
4elefone = ("GGG");
Codigo = (6);
.....
Remoo
Realizada
2. Im-lementando JPA no -rojeto J3".
Iniciamos anteriormente um pro!eto JS@ de cadastro de clientes, %ue utiliza J5B6 para
manipular as opera'es com o banco de dados, vamos construir uma implementao JPA com
Hibernate para realizar essa tare*a, e veremos as vantaens ao se desenvolver utilizando esta
tecnoloia#
A ilustrao 9: mostra o diarama de classe do pro!eto e evidencia a nova classe %ue
implementar. a inter*ace 6liente5A1 utilizando JPA# A ilustrao 9? representa o 5iarama $R,
observe %ue no houve alterao nenhuma do banco de dados#
Ilustrao 9:: 5iarama de 6lasse Adaptado para JPA
Ilustrao 9?: 5iarama $R do Pro!eto 6adastro 6lientes
6om a estrutura do pro!eto rede*inida, vamos aora a implementao# 5evemos acrescentar
a classe JPA6liente5A1 ao pro!eto, mas antes disso temos %ue adicionar ao pro!eto JS@, as *un'es
JPA com Hibernate# H. as propriedades do pro!eto e selecione a opo Project "acets# Selecione a
opo Java Persistence e cli%ue em 1V#
6onclu7da esta etapa, o pro!eto passa a possuir caracter7sticas JS@ e JPA, em outras palavras,
o pro!eto area *uncionalidades dos dois @rame+or,s# 1bserve %ue aora est. presente o ar%uivo
de con*iurao do Hibernate#
Ilustrao 9D: Adicionando @uncionalidades JPA ao Pro!eto#
Ilustrao 9M: $strutura JPA ao Pro!eto JS@#