Este documento apresenta um resumo sobre o uso da tecnologia Java Persistence API (JPA) para mapeamento objeto-relacional e persistência de dados em bancos de dados relacionais. Ele descreve como configurar o projeto no NetBeans para utilizar JPA, gerar classes de entidade e controladores a partir de tabelas do banco de dados e testar operações básicas de consulta, inserção e alteração de dados.

1. IFPA
Curso de Tecnologia em Análise e Desenvolvimento de Sistemas
Engenharia da Web
- Persistência com JPA
Prof. Cláudio Martins
claudiomartins2000@gmail.com
1

2. Roteiro da Aula
● Aprensentar a tecnologia de persistência em
Banco de Dados usando JPA
● Utilizar o Netbeans para gerar código JPA
● Desenvolver aplicações usando JPA
2

3. Mapeamento Objeto Relacional (ORM)
● Bancos de Dados utilizam tabelas relacionais (linhas x
colunas)
●
Sistemas OO utilizam objetos (instâncias x atributos);
● O ORM (Mapeamento Objeto Relacional) permite o
mapeamento de entidades e seus relacionamentos (tabelas)
em Objetos;
● Busca facilitar a persistência de dados;
3

4. Mapeamento Objeto Relacional (ORM)
4

5. Mecanismos de Persistência
● Como vimos, podemos programar diretamente em
JDBC e mapear em código os mecanismos de
persistência em objetos (CRUD), usando SQL;
● Os frameworks de persistência se apresentam
como mecanismos que simplicam a forma de tratar
os objetos, diminuindo o uso de SQL.
● Java propõe uma API de referência chamada Java
Persistence API (JPA);
● Existem várias implementações de JPA.
● Hibernate é apenas uma implementação de JPA.
5

6. O JPA
● O JPA oferece um modelo de persistência
utilizando POJOs para o mapeamento objeto-
relacional.
● Desenvolvido para a EJB 3.0, como parte da
especificação JSR 220, mas não é limitado a
EJB;
● Utiliza anotações para o mapeamento de
entidades;
● Site:
http://java.sun.com/javaee/technologies/persistence.jsp
6

7. Regras básicas de mapeamento
7

8. Entidade na JPA
● Entidade (entity) é o objeto que pode ser
gravado pelo mecanismo de persistência
● Toda entidade tem de ter um construtor sem
argumentos
● Cada atributo deve possuir seu get e set.
● Toda entidade tem de ter uma chave primária
8

9. Entidade em JPA
● Uma entidade JPA é um POJO anotado
9

10. Conceitos básico de JPA
As entidades do modelo são POJOs.
POJO é um classe java com atributos privados,
construtor vazio e métodos de acesso gets e sets.
Mapeamento objeto-relacional é realizado com:
◦ Configuração – XML (no arquivo persistence.xml)
◦ Anotações (uso de código anotado com @)
EntityManager – centraliza a interação com o JPA
PersistenceUnit – define uma unidade de
persistencia (do acesso a um banco de dados –
definido no persistence.xml)
10

11. JPA – Principais Anotações
@Entity– informa ao JPA que a classe é uma entidade e deve
ser persistida
@Table(name=“...”) – informa o nome da tabela que irá
persistir a entidade
@Id – marca uma propriedade da classe como chave primária
– identificador
@GeneratedValue – como gerar o id (chave primária)
@Column (name=“...”) – informa o nome da coluna que irá
persistir o campo
@Temporal (tipo) – Data, Hora e Data+Hora
@Transient – não persiste a coluna
11

12. Exemplo
Cliente Pedido
id 1 n id
nome data
endereco valor...
12

13. Exemplo
13

14. Exemplo JPA: Relacionamento 1-n
14

15. Exemplo JPA
15

16. Geração de Código JPA em Netbeans
16

17. Passos no Netbeans
1)Definir a conexão com o banco de dados
2)Gerar as entidades e o arquivo de
configuração (persistence.xml)
3)Gerar os controladores (DAO) de
persistência
17

18. Modelo do Banco
● Para o exemplo apresentado neste tutorial, deve
ser criado um banco de dados com as seguintes
tabelas, representando uma aplicação para uma
transportadora de cargas:
N 1
18

19. Script do Banco (1)
● Abra o console do banco e execute os scripts
SQL a seguir.
CREATE TABLE CIDADE (
COD_CIDADE INTEGER PRIMARY KEY,
NOME VARCHAR(40),
VALOR_FRETE NUMERIC(10,2)
);
CREATE TABLE DESPACHO (
NUMERO_CONTROLE INTEGER PRIMARY KEY,
NOME_CLIENTE VARCHAR(80),
PESO_CARGA NUMERIC(10,2),
COD_CIDADE INTEGER REFERENCES CIDADE,
VALOR_PAGAR NUMERIC(10,2),
DATA_DESPACHO DATE
);
19

20. Script do Banco (2)
● Popule a tabela 'Cidade'
-- POPULAR A TABELA CIDADE
INSERT INTO CIDADE VALUES (1,'RIO DE JANEIRO', 1500.0);
INSERT INTO CIDADE VALUES (2,'SÃO PAULO', 1800.0);
INSERT INTO CIDADE VALUES (3,'SÃO LUIZ', 600.0);
INSERT INTO CIDADE VALUES (4,'RECIFE', 1200.0);
INSERT INTO CIDADE VALUES (5,'SALVADOR', 2000.0);
20

21. Definição da conexão com o banco de
dados
21

22. Configurando o DRIVER JDBC NO NETBEANS
- Defina o driver JDBC do gerenciador do banco de dados.
- Em nosso exemplo, usaremos o H2 Database (verifique em que
pasta está localizado este arquivo .jar).
Na aba Serviços expanda o nó do item Banco de dados. Clique com
o direito do mouse sobre o item Drivers e selecione no menu de contexto
o único item: Novo Driver.
22

23. Configurando o DRIVER JDBC NO NETBEANS
Na caixa de diálogo Novo Driver JDBC clique no botão Adicionar... e
selecione o local onde está o arquivo do driver (no nosso caso: h2-
1.3.166.jar).
Ao selecionar, clique em “Localizar” para que o campo Classe do
Driver seja preenchido. No campo Nome preencha com o nome do
Drive (pode ser “H2 Database”). Confirme a caixa de diálogo clicando no
botão OK.
23

24. Conectando ao banco de dados
O NetBeans permite a conexão ao banco de dados, facilitando a
manipulação para consultas e operações de atualização.
Na aba Serviços clique com o direito do mouse sobre o item
Banco de Dados e selecione no menu de contexto o item Nova
Conexão.
24

25. Conectando ao banco de dados (localizando o
driver)
Na caixa de diálogo Assistente de nova conexão, em Localizar
Driver, selecione o Driver definido anteriormente (o H2 Database).
Em seguida, clique em Próximo para a janela de configuração da
conexão.
25

26. Conectando ao banco de dados: configuração de acesso
No campo URL JDBC inforoinforme a localização (URL) do banco.
No campo Nome do Usuário use o usuário que você adicionou ao criar o banco de
dados e em Senha a senha do usuário (no exemplo o usuário é o “sa” e a senha é vazia).
Marque a opção Lembrar Senha se você desejar manter a senha durante a execução do
NetBeans. Confirme clicando no botão Próximo, para a janela do esquema do banco.
26

27. Conectando ao banco de dados: esquema
A última etapa é a definição do esquema. Escolha o esquema Public. Em
seguida, clique em Finalizar e observe na aba Serviços a conexão ao
banco já estabelecida (abra os itens do esquema PUBLIC para ver as
tabelas).
27

28. Criação do projeto Java (Web)
28

29. Projeto com JPA
● Para usar a tecnologia JPA com o NetBeans, crie
um projeto normalmente (pode ser do tipo Web ou
Aplicação).
● Em nosso exemplo será um projeto Web.
● O driver do banco (neste caso, o H2) deverá estar
configurado como biblioteca do projeto.
● Para o projeto com JPA, o mecanismo escolhido
para implementar a tecnologia JPA é o EclipseLink.
● Para usar outras implementações (Hibernate,
TopLink, etc), deve-se observar as configurações
específicas para o arquivo persistence.xml e as
formas de tratar os mapeamentos.
29

30. Criando um projeto Web com JPA (1)
Crie o projeto Web escolhe a opção do menu Arquivo – Novo, Novo
Projeto. No item (Categoria) Java Web, escolha Aplicação Web.
No final, clique em Próximo.
30

31. Criando um projeto Web com JPA (2)
Em seguida, defina o nome do projeto e o local (pasta) onde ficará salvo o
projeto.
Neste exemplo, o nome do projeto é AulaWebJPA. Clique em Próximo.
31

32. Criando um projeto Web com JPA (3)
Neste passo (3), você deve escolher o servidor web e o domínio (contexto)
da aplicação (assumimos o mesmo nome do projeto).
Neste exemplo, usamos o servidor Apache Tomcat 7. Clique em
Finalizar. (Não é necessário executar o passo 4, pois nenhum framework
será adicionado ao projeto).
32

33. Estrutura do Projeto Web
O NetBeans cria toda a estrutura do projeto web e o uma página JSP de
boas vindas (index.jsp).
33

34. Adicionando o driver JDBC na biblioteca do
projeto
Para o projeto manipular banco de dados é necessário acrescentar o arquivo
do driver JDBC do banco. Neste caso, optamos pelo banco H2 Database.
Selecione no projeto o item Bibliotecas. Com o atalho, escolha uma opção
para adicionar o arquivo JDBC (driver) do banco. Neste exemplo, optou-se
por adicionar diretamente o JAR/pasta do driver no projeto.
34

35. Geração das entidades
35

36. Criando as classes de entidade do banco
Agora vamos criar as classes de entidade do banco de dados. O NetBeans
gera automaticamente o código das classes por meio de engenharia reversa
do banco de dados. Com o menu de atalho sobre a pasta Pacotes de
código-fonte escolha Novo e Classes de entidade de banco de
dados.
36

37. Escolhendo as tabelas do banco de dados
O passo seguinte é selecionar as tabelas que serão mapeadas como
classes de entidade do banco de dados.
Escolha a conexão de banco de dados (criada anteriormente). Em
seguida, clique em Adicionar todos e Próximo.
Escolha a conexão
Clique em Adicionar
37

38. Definindo o local das classes e a unidade de
persistência
Neste passo você define o nome do pacote (neste exemplo: “modelo”) onde
serão geradas as classes. Desmarque as opções Gerar anotações de
consulta e Gerar anotações JAXB. Deixe marcada a opção Criar unidade
de persistência. Em seguida, clique em Próximo.
38

39. Finalizando o processo de mapeamento
No último passo, é possível definir a classe que mapeia os relacionamentos como
associções entre as classes (por padrão o NetBeans utiliza a classe interface
Collection).
Clique em Finalizar.
39

40. Projeto com as classes entidade JPA
No final do processo, o NetBeans cria as classes de entidade no pacote “modelo”
(1), adiciona as bibliotecas da implementação JPA (EclipseLink) (2) e o arquivo
XML com as configurações de acesso ao banco no arquivo persistence.xml (3).
1
2
3 40

41. Arquivo persistence.xml
41

42. Classes Controladoras (DAO)
42

43. Gerando os Controladores (DAO) das entidades
Depois de criar as entidades, você pode gerar as classes controladoras do JPA, que
corresponde ao padrão DAO (Data Access Object), responsável pelas operações
(métodos para inserir, alterar, deletar, etc) sobre os objetos entidade.
No pacote de código-fonte, no menu de atalho escolha Novo – Classes de
Controlador JPA de classes de entidade.
43

44. Definindo os controladores das Classes de
Entidade
Em seguida, escolha quais classes de entidade serão gerados as devidas
classes de controle (DAO). Clique em Adicionar tudo, em seguida,
clique em Próximo.
44

45. Finalizando – Classes de Controle JPA
O próximo passo é a escolha do pacote onde ficarão as classes
controladoras. No exemplo, escreva modelo.dao (caso não exista o
pacote, o NetBeans irá criar para você). Clique em Finalizar.
45

46. Código gerado para um Controlador (DAO)
46

47. Compreendendo o Controlador - EntityManager
O código gerado para um Controlador exige que você informe um objeto do tipo
EntityManagerFactory.
Um EntityManagerFactory é uma classe interface que fornece o mecanismo
para criar (fabricar) objetos do tipo EntityManager. O EntityManager administra o
mapeamento entre uma classe de entidade e uma fonte de dados registrado no
arquivo persistence.xml.
Portanto, você deve saber qual o nome informado para a unidade de persistência
referenciado no arquivo persistence.xml.
No exemplo, o nome informado (gerado pelo NetBeans) é AulaWebJPAPU.
47

48. Testando um Controlador da classe Cidade
O código a seguir mostra como criar um objeto do tipo
EntityManagerFactory e como instanciar um controlador (no exemplo o
controlador DAO de Cidade).
Depois é chamar os métodos disponíveis no controlador.
EntityManagerFactory emf = Persistence.createEntityManagerFactory("aulaJPAPU");
CidadeJpaController daoCidade = new CidadeJpaController(emf);
// consultar uma cidade com código=1
Cidade c = daoCidade.findCidade(1);
System.out.println("Cidade - " + c.getNome() + " FRETE= " + c.getValorfrete());
// mostra a quantidade de cidades
System.out.println("total de cidades = " + daoCidade.getCidadeCount());
48

49. Testando um Controlador da classe Cidade:
incluindo uma “cidade”
Para incluir um objeto entidade usando o controlador, use o método
create. O método create necessita apenas de um objeto do tipo
do Controlador.
EntityManagerFactory emf = Persistence.createEntityManagerFactory("aulaJPAPU");
CidadeJpaController daoCidade = new CidadeJpaController(emf);
// criar um objeto Cidade
Cidade cid1 = new Cidade();
cid1.setNome("Bragança");
cid1.setValorfrete(new BigDecimal(550.50));
cid1.setCodcidade(12);
daoCidade.create(cid1);
49

50. Testando um Controlador da classe Cidade:
alterando um objeto “cidade”
Para editar (alterar) um objeto entidade usando o controlador, use o
método edit. O método edit necessita apenas de um objeto do tipo
do Controlador.
EntityManagerFactory emf = Persistence.createEntityManagerFactory("aulaJPAPU");
CidadeJpaController daoCidade = new CidadeJpaController(emf);
// primeiro deve-se consultar (localizar) o objeto
Cidade c = daoCidade.findCidade(1);
// depois, alterar os valores dos atributos e chama o método edit.
c.setValorfrete( new BigDecimal(100) );
daoCidade.edit(c);
System.out.println("Cidade - " + c.getNome() + " FRETE= " + c.getValorfrete());
50

51. Testando um Controlador da classe Cidade:
excluindo um objeto “cidade”
Para excluir (deletar) um objeto entidade usando o controlador, use o
método destroy. O método destroy necessita apenas do valor da
chave primária (do tipo do atributo identificador do objeto entidade).
EntityManagerFactory emf = Persistence.createEntityManagerFactory("aulaJPAPU");
CidadeJpaController daoCidade = new CidadeJpaController(emf);
// deleta a cidade cujo código = 12
daoCidade.destroy(12);
51

52. Testando um Controlador da classe Cidade:
consultando todos os objetos “cidade”
Para localizar todos os objetos de entidade usando o controlador,
use o método find...Entities, onde (…) é o nome da Entidade. O
método find...Entities retorna uma coleção de objetos do tipo da
Entidade.
EntityManagerFactory emf = Persistence.createEntityManagerFactory("aulaJPAPU");
CidadeJpaController daoCidade = new CidadeJpaController(emf);
// recupera todos os objetos da entidade Cidade
List<Cidade> cidades = daoCidade.findCidadeEntities();
for (Cidade cidade : cidades) {
System.out.println("cidade = "+cidade.getNome());
}
52

53. Atividades Práticas (Exercícios)
53

54. Exercícios (1)
A partir do tutorial presente neste documento
realize as seguintes atividade:
1) Crie um banco de dados com a tabela a
seguir (estrutura):
● Cliente
– ID (chave primária) – INTEGER
– NOME - VARCHAR(60)
– DATA_NASC - DATE
– SALDO - NUMERIC(10,2)
54

55. Exercícios (2)
2) Crie um projeto Java no NetBeans.
3) Adicione a biblioteca do driver JDBC do
banco (pode ser o H2 Database)
4) Defina a conexão ao banco usando o
serviço de banco de dados do NetBeans
5) Gere a classe entidade (Cliente)
6) Gere o controlador da entidade (Cliente)
55

56. Exercícios (usando o controlador DAO)
A partir do código gerado (classes entidade e controlador),
crie uma classe de teste com os seguinte métodos de
teste:
1) Método para inclusão de um cliente
2) Método para alterar dados de um cliente a partir do
valor informado do “id” do cliente. Alterar o nome e o
saldo do cliente.
3) Método para recuperar um cliente a partir do valor
informado do “id” do cliente
4) Método para deletar um cliente a partir do “id”
informado.
5) Método para listar todos os clientes. Mostre (console)
o id, o nome e o saldo. 56