CESUMAR – Prof. Sandro Marcelo Pascoal Página
48/68
Java Persistence API (JPA)
Você já percebeu que gravar informações num banco de dados usando puramente JDBC dá muito
trabalho. Mas, não só você como também um grupo de pessoas já passaram pela mesma experiência
e então criaram uma forma menos trabalhosa tornando o trabalho mais eficiente.
A idéia foi de criar algo onde, para gravar um objeto, não fosse necessário montar um
insert
mas sim
chamar um método passando o próprio objeto e o tal método faz o trabalho.
Esbarrou-se então no primeiro problema onde temos bancos de dados relacionais e o programa Java
orientado a objeto. Vejamos um exemplo.
No cadastro de clientes de uma empresa que faz vendas há o campo cidade. A representação deste
dado no banco de dados relacional difere da representação da classe no diagrama Classes.
Lembrando que o desenvolvimento da aplicação Java baseia-se na UML.
Veja as figuras 1 e 2 e note que na figura 1 o campo CLIENTE.codCidade é apenas mais um de tipo
inteiro que possui um relacionamento com CIDADE.codCidade. Então, codCidade em cliente guarda
somente o identificador da cidade. Na figura 2, o atributo cidade é um objeto dentro de Cliente que
não traz somente um identificador mas sim uma instância de Cidade com todos os atributos.
Figura 1: DER do BD relacional Figura 2: Diagrama de Classes
A gravação dos dados neste cenário fica mais complicada exigindo muitas linhas de código para
poucos comandos SQL. Porém, como todo bom programador que não gosta de escrever muitos
códigos para rotinas repetitivas, a solução encontrada foi o desenvolvimento de frameworks que faz o
trabalho difícil para nós.
Neste ponto entra em ação o
Java Persistence API
(JPA) provendo um mapeamento
objeto-relacional resolvendo o problema da gravação nos dados em bancos de dados relacionais pelas
aplicações Java.
Veja na figura 3 uma representação de comunicação da aplicação Java com o banco de dados.
Note que o JDBC é utilizado pelo JPA para manipulação de dados.
CESUMAR – Prof. Sandro Marcelo Pascoal Página
49/68
Figura 3: Comunicação da aplicação com o BD.
Para colocar em prática um exemplo, antes é preciso conhecer alguns elementos necessários para
utilização do JPA.
Leia os tópicos POJO e Anotações.
Plain Old Object (POJO)
Para persistir objetos com alguns frameworks Java, neste caso o JPA, a classe precisa ser escrita com
alguns elementos a fim de poder ser manipulada pelos frameworks.
Tais elementos criam uma convenção de escrita das classes que fazem com sejam chamadas de
POJOs.
Um POJO define que a classe deve ser escrita:
Implementando a interface
java.io.Serializable
;
Possua um construtor sem argumento, ou seja, vazio.
Contenha os métodos gets e sets para cada um dos atributos.
Na listagem 1 apresenta uma classe comum, como as que trabalhamos até o momento. Já a listagem
2 apresenta uma classe POJO.
Ainda na listagem 2 foi utilitada a classe
java.io.Serializable
. Para compreender leia o tópico
seguinte.
CESUMAR – Prof. Sandro Marcelo Pascoal Página
50/68
public class Aluno { private int ra; private String nome; public String getNome() { return nome;
}
public void setNome(String nome) { this.nome = nome;
}
public int getRa() { return ra;
}
public void setRa(int ra) { this.ra = ra;
} }
Listagem 1: Classe Java comum.
import java.io.Serializable;
// Implementa classe de Serialização permitindo assim // que os objetos Aluno possam ser transferidos de // um meio para outro.
public class Aluno implements Serializable { private int ra;
private String nome;
// Construtor sem argumentos public Aluno() { }
// Métodos gets e sets public String getNome() { return nome;
}
public void setNome(String nome) { this.nome = nome;
}
public int getRa() { return ra;
}
public void setRa(int ra) { this.ra = ra;
} }
CESUMAR – Prof. Sandro Marcelo Pascoal Página
51/68
Serialização
Na listagem 2 do tópico POJO a classe Aluno implementa a classe
java.io.Serializable
permitindo que
qualquer objeto desta classe possa ser serializado.
Serialização, segundo Yung (2005), é o processo de armazenar os dados de um objeto e envolve a
transformação das variáveis ou atributos de um objeto em memória, em bytes ou caracteres, ou seja,
converter dados inteligíveis em números para podermos guardar em um arquivo.
O trabalho de gravar os objetos fica por conta do JPA. Para felicidade dos programadores basta
escreverem a classe implementando a interface
Serializable
. Essa interface não possui métodos,
apenas serve para indicar ao Java que os objetos da classe e subclasses são possíveis de serem
persistidos.
Annotations
Os frameworks de persistência não fazem mágica, mas ajudam bastante no trabalho de gravação de
objetos em banco de dados relacional.
Não faz mágica porque eles necessitam de uma configuração prévia na classe indicando qual o nome
da entidade no banco de dados, quem dos atributos é chave primária no banco, qual o tipo
relacionamento com outras classes, ....
Vamos para um exemplo para melhor explicar.
Na classe Aluno abaixo podemos reconhecer dois atributos (ra e nome).
O JPA é capaz de gravar um objeto Java dentro da entidade Aluno no banco de dados (BD)
relacional, mas, como o JPA sabe o nome da entidade no BD ? Como sabe qual o atributo da classe é
a chave primária no BD ?
O framework só poderá fazer seu trabalho se você ajudar ele com algumas informações. É preciso
indicar na classe Aluno qual o nome da entidade no BD, qual o atributo da classe é a chave primária
no BD entre outros recursos..
import java.io.Serializable;
public class Aluno implements Serializable { private int ra;
private String nome; public Aluno() { } // Métodos gets e sets public String getNome() { return nome;
}
public void setNome(String nome) { this.nome = nome;
}
public int getRa() { return ra;
}
public void setRa(int ra) { this.ra = ra;
} }
CESUMAR – Prof. Sandro Marcelo Pascoal Página
52/68
Para dar estas informações usamos o recurso do Java chamado
Annotations
.
É uma “decoração” inserida na classe que é compilada dentro da mesma e interpretada
em tempo de execução por algum framework, neste caso JPA.
Os
annotations
são usados com três finalidades:
1.
Para documentação – Podem ser utilizados para inserir informações dentro da classe, como por
exemplo o autor da classe, datas, dados relevantes, ....
2.
Para o compilador – Usados pelo compilador para detectar erros e suprimir mensagens. Ex:
@Deprecated, @Override, ....
3.
Para processamento
runtime
– Indicados para serem utilizados por informações que precisam
ser processadas obtidas no momento da execução da aplicação.
Os exemplos JPA estão ligados ao item 3.
A classe Aluno da listagem 4 está com as anotações mínimas necessárias para o JPA poder persistir
qualquer objeto Aluno na entidade aluno no banco.
Importante !!! O nome da classe no Java e os atributos devem ter os mesmos nomes usados no
banco de dados. Para este exemplo pelo menos.
Mais importante ainda !!! Para usar o pacote javax.persistence
é necessário incluir no seu projeto
o ejb3-persistence.jar.
import java.io.Serializable; import javax.persistence.Entity; import javax.persistence.Id;
// Indica para o JPA que esta classe é a mesma que a entidade no banco de dados @Entity
public class Aluno implements Serializable {
@Id // Indica que o atributo logo abaixo é a PK da tabela no BD. private int ra;
private String nome;
// Construtor sem argumentos public Aluno() { }
// Métodos gets e sets public String getNome() { return nome;
}
public void setNome(String nome) { this.nome = nome;
}
public int getRa() { return ra;
}
public void setRa(int ra) { this.ra = ra;
} }
Listagem 4: Classe Aluno com anotações.
Este é um exemplo muito básico e inicial. Veja a lista de anotações abrindo o link da referência
bibliográfica de Oracle (2009). Também, veja o projeto criado no tópico seguinte.
CESUMAR – Prof. Sandro Marcelo Pascoal Página
53/68
Criando um projeto com persistência JPA
Neste tópico iremos criar um projeto completo no NetBeans manipulando dados num banco
PostgreSQL gravando e recuperando os objetos com JPA.
O exemplo consiste em criar um cadastro de produtos separando-os por grupo, por exemplo:
Uma empresa que comercializa materiais para construção vende algumas ferramentas como alicate,
chaves, furadeiras, ... Assim, ela cadastraria um grupo chamado FERRAMENTAS e para cada produto
cadastrado classificaria seu grupo.
A tecnologia mais adequada para construir este software é utilizar um banco de dados relacional.
Porém, como a linguagem que estamos usando é o Java, na qual é orientada a objetos e, onde a
associação entre as classes difere da estrutura de um SGBDR (Sistema Gerenciador de Banco de
Dados Relacional), faz-se necessário fazer um mapeamento objeto-relacional nos momentos de
gravação e recuperação de dados do BD.
Veja os diagramas de classe e de entidade e relacionamento (DER).
DER das entidades do banco de Diagrama de Classes do
dados PostgreSQL projeto em Java
Vamos então listar alguns passos para construir este programa.
1.
Criar o banco de dados no PostgreSQL
2.
Iniciar no NetBeans criando um projeto novo
3.
Copiar os .jar necessários
4.
Criar o pacote modelo escrevendo as classes de negócio dentro dele. Estas classes devem ser
POJO e com anotações para o JPA.
5.
Criar o pacote dao contendo os métodos para conexão com BD e manipulação das entidades
grupo e produto.
6.
Criar os pacotes modelo e teste contendo as classes funcionais.
Agora, “mãos à obra”.
CESUMAR – Prof. Sandro Marcelo Pascoal Página
54/68
1.
Criar o banco de dados
Com o PostgreSQL instalado, crie um banco de dados com o nome jpa e nele os recursos e entidades
de grupo e produto. A listagem 5 apresenta as instruções a serem executadas no banco jpa.
Os
sequences
são utilizados para gerar os códigos automaticamentes para os campos pk das
entidades.
CREATE SEQUENCE GRUPO_CODGRUPO_SEQ; CREATE TABLE GRUPO
(
CODGRUPO SMALLINT PRIMARY KEY DEFAULT NEXTVAL('GRUPO_CODGRUPO_SEQ'), NOME VARCHAR(30)
);
CREATE SEQUENCE PRODUTO_CODPRODUTO_SEQ; CREATE TABLE PRODUTO
(
CODPRODUTO INTEGER NOT NULL PRIMARY KEY DEFAULT NEXTVAL('PRODUTO_CODPRODUTO_SEQ'), DESCRICAO VARCHAR(50), QUANTIDADE INTEGER, PRECO_CUSTO REAL, MARGEM_LUCRO REAL, PRECO_VENDA REAL, CODGRUPO SMALLINT,
FOREIGN KEY (CODGRUPO) REFERENCES GRUPO (CODGRUPO) );
Listagem 5: Estrutura do banco de dados jpa no PostgreSQL
2.
Iniciando o projeto JPA no NetBeans.
Abra o NetBeans e crie Aplicativo Java com o nome JPA.
Na tela seguinte selecione a pasta, digite o nome do projeto (JPA) e desmarque a opção que cria a
classe Main.
CESUMAR – Prof. Sandro Marcelo Pascoal Página
55/68
3. Arquivos .jar necessários
Para fazer as anotações nas classes, conectar com PostgreSQL e usar o JPA é necessário acoplar a
aplicação Java arquivos que contenham as funções que permites tais tarefas.
Estes arquivos são de extensão .jar e cada um para uma função específica. Veja a lista que é utilizada
para este projeto.
postgresql-8.3-604.jdbc4.jar – Utilizado pela api JDBC do Java para conexão e manipulação
de bancos Postgree. Este .jar é distribuído pelo fabricante (PostgreSQL) e pode ser baixado em
http://jdbc.postgresql.org/. Em
Download
você encontra dois
drivers
, este que estou usando é
compatível com Java 1.6. Caso seu Java seja de versão abaixo de 1.6 baixe o outro driver para
jdbc3.
ejb3-persistence.jar – Necessário para a inserção dos
annotations
nas classes que serão
persistidas (Grupo e Produto).
toplink-essentials.jar e toplink-essentials-agent.jar – Necessários para fazer a conexão e
manipulação de dados no banco de dados.
Para colocar estes arquivos no projeto faça o seguinte:
1.
Crie na pasta do seu projeto uma pasta chamada lib.
2.
Copie os arquivos .jar para esta pasta.
3.
Configure seu projeto JPA para usar estes arquivos. Veja os passos.
Clique com botão direito em “Bibliotecas” e selecione “Adicionar
JAR/pasta”.
Localize a pasta lib dentro do projeto JPA, selecione todos os
arquivos .jar da pasta lib, deixe a opção “Caminho relativo”
marcada e confirme. (Veja tela abaixo).
CESUMAR – Prof. Sandro Marcelo Pascoal Página
56/68
4.
Criando classes modelo (Grupo e Produto)
Para a utilização pelo framework JPA, as classes que serão persistidas devem ser POJO e
conter as anotações.
Importante !!! Para escrever as anotações nas classes (@Entity, @Id, ...) é preciso anexar um .jar
ao seu projeto. Veja o tópico 3 acima.
Crie
um
pacote
chamado modelo e
nele crie as classes
Grupo e Produto.
Veja figura ao lado.
Importante !!! As classes a serem persistidas precisam estar listadas no persistence.xml.
Veja no tópico 5.
A anotações (annotations) são colocados na linha logo acima do recurso que desejamos anotar.
Para indicar que a classe Grupo é uma entidade a ser persistida coloca-se o
@Entity
na linha antes
de
public classe Grupo....
A mesma regra vale para indicar que o atributo codGrupo é a chave primária da entidade no banco.
Anota-se
@Id
na linha antes de
private int codGrupo
. Além do @Id, o atributo codproduto possui
a anotação
@GeneratedValue
que identifica a estratégia de autonumeração do código. Assim, um
atributo pode ter mais de uma anotação.
Analise o código das classes Grupo e Produto seguinte.
package modelo; import java.io.Serializable; import javax.persistence.Entity; import javax.persistence.GeneratedValue; import javax.persistence.GenerationType; import javax.persistence.Id;
// Indica ao JPA que a classe Grupo deve ser gravada no banco // de dados exatamente na entidade grupo.
@Entity
public class
Grupo
implements Serializable {/* @Id - Indica que o atributo logo na linha abaixo é a chave primária * @ GeneratedValue... - Indica que o código será gerado automaticamente * pela estratégia IDENTITY que usa um sequence do banco de dados montado * com o nome padrão de GRUPO_CODGRUPO_SEQ.
* Note que todas estas anotações são exatamente antes do atributo anotado. */
@Id
@GeneratedValue(strategy=GenerationType.IDENTITY) private int codGrupo;
private String nome; public Grupo() { }
public int getCodGrupo() { return codGrupo;
CESUMAR – Prof. Sandro Marcelo Pascoal Página
57/68
}
public void setCodGrupo(int codGrupo) { this.codGrupo = codGrupo;
}
public String getNome() { return nome;
}
public void setNome(String nome) { this.nome = nome;
} }
Listagem 6: Classe Grupo
Em especial na classe Produto há a anotação @ManyToOne para o atributo grupo. Em conjunto com
@JoinColumn definem que o atributo produto.codGrupo é o campo de chave estrangeira no
relacionamento entre as entidades Produto e Grupo no BD.
Também, alguns atributos possuem a anotação @Column sendo utilizada para indicar o nome do
campo na entidade produto que neste caso foi propositalmente inserido na classe com o nome
diferente do BD.
package modelo;
import java.io.Serializable; import javax.persistence.*; @Entity
public class
Produto
implements Serializable { @Id@GeneratedValue(strategy = GenerationType.IDENTITY) private int codProduto;
private String descricao; private int quantidade;
// No BD, o campo tem o nome diferente do atributo da classe // Neste caso é possível incluir uma anotação para a coluna e // especificar o que for necessário.
@Column(name = "preco_custo") private double precoCusto; @Column(name = "margem_lucro") private double margemLucro; @Column(name = "preco_venda") private double precoVenda; @ManyToOne
@JoinColumn(name = "codgrupo") private Grupo grupo;
// Construtor vazio. public Produto() { }
public int getCodProduto() { return codProduto;
CESUMAR – Prof. Sandro Marcelo Pascoal Página
58/68
public void setCodProduto(int codProduto) { this.codProduto = codProduto;
}
public String getDescricao() { return descricao;
}
public void setDescricao(String descricao) { this.descricao = descricao;
}
public int getQuantidade() { return quantidade;
}
public void setQuantidade(int quantidade) { this.quantidade = quantidade;
}
public double getPrecoCusto() { return precoCusto;
}
public void setPrecoCusto(double precoCusto) { this.precoCusto = precoCusto;
}
public double getMargemLucro() { return margemLucro;
}
public void setMargemLucro(double margemLucro) { this.margemLucro = margemLucro;
}
public double getPrecoVenda() { return precoVenda;
}
public void setPrecoVenda(double precoVenda) { this.precoVenda = precoVenda;
}
public Grupo getGrupo() { return grupo;
}
public void setGrupo(Grupo grupo) { this.grupo = grupo;
} }
CESUMAR – Prof. Sandro Marcelo Pascoal Página
59/68
5.
Persistence Unit
(Unidade de persistência)
O primeiro passo para utilização da persistência com JPA é prover a conexão com um banco de
dados. Esta feita por meio da configuração de um arquivo .xml e uma classe que retorne a conexão.
A classe será criada no tópico seguinte.
A unidade de persistência é um arquivo chamado
persistence.xml
que descreve o driver de banco de
dados, nome do banco, usuário e senha da conexão. Também pode conter mais configurações,
porém não são relevantes no momento.
No pacote de códigos fontes do seu projeto, crie um pacote com o nome META-INF.
Importante !!! O JPA irá procurar pelo persistence.xml no pacote META-INF que deve
estar na raiz projeto.
Clique com botão direito em META-INF e selecione a opção Novo -> Outro. Em Outro, selecione
XML na lista de categorias e em tipos de arquivos Documento XML. Coloque o nome “persistence”
(sem o .xml) e confirme.
Agora, no arquivo persistence.xml, copie e cole o conteúdo abaixo dentro dele. Altere o que for
necessário para sua conexão.
Importante !!! Note que no persistence.xml há duas vezes a tag <class>. Deve ser feito
uma para cada classe do seu projeto que deseja persistir pelo JPA.
<?xml version="1.0" encoding="UTF-8"?>
<persistence version="1.0" 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_1_0.xsd">
<persistence-unit name="ExemploJPA" transaction-type="RESOURCE_LOCAL"> <provider>oracle.toplink.essentials.PersistenceProvider</provider>
<!-- Relacione aqui todas as classes do seu projeto que serao persistidas --> <class>modelo.Grupo</class>
<class>modelo.Produto</class> <!-- Propriedades da conexão -->
<!-- toplink... é o provedor de conexão utilizado. Pederia ser o Hibernate também. -->
<properties>
<property name="toplink.jdbc.driver" value="org.postgresql.Driver"/>
<property name="toplink.jdbc.url" value="jdbc:postgresql://localhost/jpa"/> <property name="toplink.jdbc.user" value="postgres"/>
<property name="toplink.jdbc.password" value="screen"/> </properties>
</persistence-unit> </persistence>
CESUMAR – Prof. Sandro Marcelo Pascoal Página
60/68
6. Entity Manager
Como será que um ojeto Produto, por exemplo, será gravado no banco de dados ?
Esta é a função do
Entity Manager
, porém, para obter um objeto do tipo não é tão simples.
Analise a figura seguinte extraída do livro de Keith (2006) e adaptada com algumas explicações.
1.
A classe de persistência (
Persistence
) cria uma fábrica de gerenciadores de entidades
(
EntityManagerFactory
). A multiplicidade * indica que podem ser criadas várias fábricas a partir
da classe de persistência.
2.
O
EntityManagerFactory
é configurado através da unidade de persistência (persistence.xml).
Então, ele é o responsável direto pela conexão com o BD. A multiplicidade 1:1 indica que um
objeto EntityManagerFactory só pode estar conectado a um banco de dados.
3.
O
EntityManager
é o responsável por persistir (gravar) os objetos e lê-los do banco de dados
trazendo-os para dentro da aplicação.
4.
Como há a possibilidade da existência de vários objetos
EntityManager
(em), pode acontecer de
dois ou mais
EntityManager
executarem selects e retornarem um mesmo produto, por exemplo.
Assim, um objeto manipulado (
PersistenteContext
) pode estar presente em vários
EntityManager
mas não pode estar duplicado dentro do mesmo.
Portanto, num projeto usando JPA precisamos de um objeto
EntityManager
para executar os
comandos, e, este por sua vez é obtido através do
EntityManagerFactory
. Veja o exemplo.
EntityManagerFactory emf = Persistence.createEntityManagerFactory("ExemploJPA"); EntityManager em = emf.createEntityManager();
O String “ExemploJPA” deve ser o nome da unidade der persistência encontrada no persistence.xml.
O código completo com exemplo está no tópico “8. Classe Dao”.
CESUMAR – Prof. Sandro Marcelo Pascoal Página
61/68
7. Métodos para inserção, alteração, exclusão e recuperação de dados.
Com um EntityManager instanciado (ver tópico 6) é possível executar os comandos de manipulação
de dados.
em.persist(produto); // insere ou atualizar um registro no banco
em.find(produto.class, 1); // recupera um objeto Produto do BD com código = 1 em.remove(produto); // remove o registro do banco de dados
Veja no tópico seguinte o código completo para manipulação de dados.
8. Classe Dao (conectando e manipulando dados)
Crie no projeto JPA um pacote chamado dao.
Neste pacote crie agora uma classe chamada Dao e transcreva o código seguinte.
package dao; import java.util.Collection; import javax.persistence.EntityManager; import javax.persistence.EntityManagerFactory; import javax.persistence.Persistence; import javax.persistence.Query; public class
Dao
{private static EntityManagerFactory emf = null; private static EntityManager em = null;
// Retorna o objeto EntityManager usado na execução dos comandos. private static EntityManager getEm() {
if (em == null) {
// A primeira vez que este método é invocado instancia os objetos try {
/* A instrução seguinte obtem uma "Fábria de Entity Manager" * O parametro "ExemploJPA" é o nome do persistence-unit * definido dentro do persistence.xml. Isso quer dizer que * é esta conexão que o emf vai executar.
*/
emf = Persistence.createEntityManagerFactory("ExemploJPA"); // Instancia um objeto EntityManager
em = emf.createEntityManager(); } catch (Exception e) { System.out.println(e.getMessage()); } } return em; }
// Método utilizado para iniciar uma transação public static void startTransaction() {
getEm().getTransaction().begin(); }
// Método utilizado para confirmar uma transação aberta
// gravando assim definitivamente os registros no banco de dados public static void commitTransaction() {
getEm().getTransaction().commit(); }
CESUMAR – Prof. Sandro Marcelo Pascoal Página
62/68
// Método utilizado para desfazer os comandos realizados desde // quando a transação foi aberta
public static void rollbackTransaction() { getEm().getTransaction().rollback(); }
// Método persiste (grava) um objeto no banco de dados
// É necessário a utilização de transação na qual estudaremos mais tarde. public static void persist(Object obj) {
try { startTransaction(); getEm().persist(obj); commitTransaction(); } catch (Exception e) { System.out.println(e.getMessage()); rollbackTransaction(); } }
// Método busca do banco de dados um objeto com a chave primária // conforme passada por parâmetro
public static Object find(Class classe, Object pk) { try { return getEm().find(classe, pk); } catch (Exception e) { System.out.println(e.getMessage()); } return null; }
// Método remove um objeto do banco de dados public static void remove(Object obj) { try { getEm().remove(obj); } catch (Exception e) { System.out.println(e.getMessage()); } }
// Obtem a lista de todos os objetos da classe passada como parâmetro /* A instrução SQL montada (SELECT r FROM Classe r) é um SQL baseado na * Java Persistence Query Language (JPQL)
* "r" não é o nome de uma coluna mas sim o nome dados a um objeto da Classe */
public static Collection listarTodos(Class classe) {
Query query = getEm().createQuery("SELECT r FROM " + classe.getSimpleName() + " r" );
return (Collection) query.getResultList(); }
}
CESUMAR – Prof. Sandro Marcelo Pascoal Página
63/68
9. Testando
Crie agora no projeto JPA o pacote teste.
Nele, crie uma classe chamada Teste e transcreva o código seguinte.
package teste;
import modelo.Grupo; import dao.Dao;
import java.util.Collection; import modelo.Produto;
public class
Teste
{public static void main(String[] args) {
System.out.println("--- TESTES COM A CLASSE GRUPO ---"); Grupo grupo = new Grupo(); // Novo objeto
grupo.setNome("FERRAMENTAS"); // Não precisa definir o CodGrupo // --- INSERINDO ---
System.out.println("Inserindo grupo....");
Dao.persist(grupo); // Grava o objeto no banco de dados
// Apresenta os dados do objeto inclusive com o código do grupo // gerado automaticamento pelo sequence e capturado pela api de // persistência.
System.out.println("Grupo inserido código: " + grupo.getCodGrupo() + " - nome: " + grupo.getNome());
// --- LOCALIZANDO --- // Localiza e retorna do banco o grupo código 1
grupo = (Grupo) Dao.find(Grupo.class, 1);
System.out.println("Grupo localizado no BD código: " + grupo.getCodGrupo() + " - nome: " + grupo.getNome());
// --- ATUALIZANDO --- // Modifica a nome e grava grupo
System.out.println("Modificando registro (update)...."); grupo.setNome("MATERIAIS ELÉTRICOS");
Dao.persist(grupo); // Método persist pode inserir ou atualizar // --- REMOVENDO --- // Insere e remove um grupo do banco de dados.
System.out.println("Removendo registro...."); grupo = new Grupo();
grupo.setNome("TESTE DE EXCLUSÃO"); Dao.persist(grupo);
Dao.remove(grupo);
// --- INSERINDO ALGUNS PARA LISTAGEM --- // Insere mais alguns grupos para poder listar
grupo = new Grupo();
grupo.setNome("HIDRÁULICOS"); Dao.persist(grupo);
grupo = new Grupo(); grupo.setNome("LOUÇA");
CESUMAR – Prof. Sandro Marcelo Pascoal Página
64/68
// --- LISTANDO --- // Collection é parecido com ArrayList
System.out.println("Listando registros....");
System.out.println("---"); Collection<Grupo> grupos = Dao.listarTodos(Grupo.class);
// O for "diferente" abaixo é chamado de (for each) onde // g é um objeto grupo e "grupos" é a lista (Collection) for (Grupo g : grupos) {
System.out.println("Código: " + g.getCodGrupo() + " nome: " + g.getNome());
}
System.out.println("---"); // --- System.out.println("--- TESTES COM A CLASSE PRODUTO ---"); // Instancia um grupo para o produto
grupo = new Grupo();
grupo.setNome("LUMINÁRIA"); Dao.persist(grupo);
// --- INSERINDO --- // Instancia um novo produto
Produto prod = new Produto();
prod.setDescricao("CONJUNTO TASHIBA 2x40W"); prod.setQuantidade(0); prod.setPrecoCusto(27.0); prod.setMargemLucro(48.0); prod.setPrecoVenda(39.96); prod.setGrupo(grupo); System.out.println("Inserindo produto...."); Dao.persist(prod);
System.out.println("Produto inserido código: " + prod.getCodProduto() + " - Descrição: " + prod.getDescricao());
// --- LISTANDO --- // Collection é parecido com ArrayList
System.out.println("Listando produtos....");
System.out.println("---"); Collection<Produto> produtos = Dao.listarTodos(Produto.class);
for (Produto p : produtos) {
System.out.println("Código : " + p.getCodProduto()); System.out.println("Descrição : " + p.getDescricao()); System.out.println("Quantidade: " + p.getQuantidade()); System.out.println("Custo : " + p.getPrecoCusto()); System.out.println("Margem : " + p.getMargemLucro() + " %"); System.out.println("Venda : " + p.getPrecoVenda()); System.out.println("Grupo : " + p.getGrupo().getCodGrupo() + " " + p.getGrupo().getNome()); System.out.println("---"); } } }
CESUMAR – Prof. Sandro Marcelo Pascoal Página
