Java Persistence API (JPA)

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 objetorelacional 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 48/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 49/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; Lisgatem 2: Classe POJO. CESUMAR Prof. Sandro Marcelo Pascoal Página 50/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; Listagem 3: Classe Aluno sem informações para framework de persistência CESUMAR Prof. Sandro Marcelo Pascoal Página 51/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 52/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 dados PostgreSQL Diagrama de Classes do 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 53/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 54/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). Agora seu projeto pode utilizar os recursos destas APIs prontas. CESUMAR Prof. Sandro Marcelo Pascoal Página 55/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 56/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 57/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; Listagem 7: Classe Produto CESUMAR Prof. Sandro Marcelo Pascoal Página 58/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> Listagem 8: Conteúdo do persistence.xml CESUMAR Prof. Sandro Marcelo Pascoal Página 59/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 60/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 61/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(); Listagem 9: Classe Dao para conexão, persistência e recuperação dos dados. CESUMAR Prof. Sandro Marcelo Pascoal Página 62/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 63/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("------------------------------------------------"); Listagem 10: Classe de Teste CESUMAR Prof. Sandro Marcelo Pascoal Página 64/68

Referência bibliográfica do JPA Sun Microsystems. The Java EE 5 Tutorial. Disponível em: http://java.sun.com/javaee/5/docs/tutorial/doc/bnbpz.html. Acessado em: 25 maio 2009a. Wikipédia. Plain Old Java Objects. Disponível em: http://pt.wikipedia.org/wiki/pojo Acessado em: 01 junho 2009a. Wikipédia. JavaBeans. Disponível em: http://pt.wikipedia.org/wiki/javabean. Acessado em: 01 junho 2009b. Yung, Leandro. ProjessorJ: Serialização de objetos. Revista Mundo Java. Curitiba, ano III, n.13, p12-13, 2005. Sun Microsystems. The Java Tutorials: Annotations. Disponível em: http://java.sun.com/docs/books/tutorial/java/javaoo/annotations.html. Acessado em:04 junho 2009b Oracle. TopLink JPA Annotation Reference. Disponível em: http://www.oracle.com/technology/products/ias/toplink/jpa/resources/toplink-jpa-annotations.html. Acessado em 04 junho 2009. Keith, Mike; Schincariol, Merrick. Pro EJB 3. Java Persistence API. Berkeley, CA: Apress, 2006. CESUMAR Prof. Sandro Marcelo Pascoal Página 65/68