1 / 48

Curso de Linguagem Java

Marcos Mendes. Curso de Linguagem Java. 2º Semestre - 2007. JPA - Java Persistence API (Beans de Entidade). Referência Bibliográfica: Enterprise JavaBeans 3.0 Bill Burke & Richard Monson Editora. Prentice Hall

fredricka-elijah
Download Presentation

Curso de Linguagem Java

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Marcos Mendes Curso de Linguagem Java 2º Semestre - 2007

  2. JPA - Java Persistence API(Beans de Entidade) Referência Bibliográfica: • Enterprise JavaBeans 3.0 Bill Burke & Richard Monson Editora. Prentice Hall • Desenvolvendo Aplicações Web com JSP, Servlets, JSF, Hibernate, EJB 3 e Ajax Edson Gonçalves Editora Ciência Moderna • Revista JavaMagazine edições 39 e 44 • Revista MundoJava edição 24 • Página da Sun sobre a tecnologia JPA http://java.sun.com/javaee/technologies/persistence.jsp

  3. JPA – Java Persistence API Arquitetura Aplicação Java Java Persistence API Provedor JPA API JDBC Driver JDBC Banco De Dados

  4. JPA – Java Persistence API Conceitos Parte integrante da JavaEE 5 Disponível a partir da Java5 Definida na JSR220 – Enterprise JavaBeans 3.0 Padroniza o Mapeamento Objeto Relacional Não depende de Container para funcionar Baseada no conceito de POJOs (Plain Old Java Object) Utiliza amplamente Annotations (Progamação Declarativa) Pacote javax.persistence

  5. JPA – Java Persistence API • Os objetos persistentes são denominados Entities(Entidades) Estas Entidades devem possuir um identificador(chave primária) e um construtor sem parâmetros. • Unidade de Persistência Conjunto de classes mapeadas para um banco de dados relacional. Esse mapeamento é feito através de um arquivo descritor de implantação chamado persistence.xml que é gravado na pasta META-INF e que pode conter a configuração de várias unidades de persistência. • Contexto de Persistência(Persistence Context) Ambiente (sessão) que envolve o conjunto de instâncias de entidades gerenciadas pelo Entity Manager.

  6. JPA – Java Persistence API Gerenciador de Entidades (Entity Manager) javax.persistence.EntityManager Serviço que gerenciará o conjunto de entidades registradas dentro de um contexto. Monitorando as alterações feitas nos objetos deste contexto de persistência, gravando assim essas alterações no banco de dados. Provedor de Persistência (Persistence Provider) É como se fosse um driver JPA para uma determinada ferramenta de mapeamento objeto-relacional. Mais específicamente, é a classe que implementa a interface javax.persistence.PersistenceProvider São alguns exemplos de fornecedores de provedores de persistência: Oracle TopLink, Hibernate, Kodo, Open JPA, etc.

  7. JPA – Java Persistence API • Ciclo de Vida / Estados de um objeto Objeto não existe clear( ) ou quando o EntityManager é fechado new DETACHED find( ) NEW merge( ) persist( ) MANAGED remove( ) Garbage Collector REMOVED

  8. JPA – Java Persistence API Mapeamento Básico de Entidades É feito com o uso de anotações nas classes persistentes. @Entity – Marca uma classe como entidade persistente. Esta classe deve possuir um construtor sem parâmetros. @Table – Define o nome da Tabela onde os objetos serão persistidos. @Id – Define o atributo que constitui a chave primária. @GeneratedValue – Define um campo auto-incremento. @Column – Define o nome da coluna onde o atributo será salvo. @Transient – Define que um atributo não será salvo no banco de dados.

  9. JPA – Java Persistence API Exemplo de Entidade import javax.persistence.*; @Entity @Table(name = "Aluno") public class Aluno { @Id @GeneratedValue (strategy=GenerationType.IDENTITY) @Column(name = "id", nullable = false, columnDefinition = "integer") private int id; @Column(name = "nome", length = 50, nullable = false) private String nome; @Column(name = "ra") private long ra; //getters e setters omitidos }

  10. JPA – Java Persistence API Exemplo de Entidade (usando mapeamentos padrão) import javax.persistence.*; @Entity public class Aluno { @Id @GeneratedValue private int id; private String nome; private long ra; //getters e setters omitidos }

  11. JPA – Java Persistence API No código da aplicação que utiliza classes persistentes: Criar um Gerenciador de Entidades através de uma fábrica: EntityManagerFactory emf = Persistence.createEntityManagerFactory("unidade"); EntityManager em = emf.createEntityManager(); Iniciar uma Transação: em.getTransaction().begin(); Criar uma Entidade: Entidade e = new Entidade(); Persistir uma Entidade: em.persist(e); Localizar uma Entidade: Entidade e = em.find(Entidade.class, chave); Sincronizar uma Entidade: e = em.merge(e); Eliminar uma Entidade: em.remove(e); Encerrar uma Transação: em.getTransaction().commit();

  12. JPA – Java Persistence API Interface EntityManager (alguns métodos) void persist(Object objeto) Persiste uma entidade, torna-a gerenciada pelo Gerenciador de Entidades. Qualquer alteração na entidade será refletida no banco de dados. <T> T merge(T entidade) Sincroniza os dados no banco de dados com os atributos da entidade. Retorna um objeto gerenciado(managed). Não pode ser usado em um objeto REMOVED. void refresh(Object entidade) Sincroniza os atributos na entidade com os dados do banco de dados. void remove(Object entidade) Remove uma entidade do banco de dados. <T> T find(Class<T> classeEntidade, Object chavePrimária) Retorna uma entidade(MANAGED) através de sua chave primária. Retorna null caso a chave não seja encontrada.

  13. JPA – Java Persistence API Query createQuery(String sql) Cria uma consulta dinâmica. Query createNamedQuery(String nomeConsulta) Cria uma consulta nomeada. EntityTransaction getTransaction( ) Retorna a transação do EntityManager. Interface EntityManager (alguns métodos) void begin( ) Inicia uma transação. void commit( ) Encerra uma transação, gravando quaisquer alterações no banco de dados. void rollback( ) Desfaz quaisquer alterações desde o início da transação.

  14. JPA – Java Persistence API Exemplo de Aplicação JavaSE usando Oracle TopLink Baixe o Oracle TopLink através do link: http://www.oracle.com/technology/products/ias/toplink/jpa/download.html Coloque o arquivo baixado em uma pasta de trabalho e execute o seguinte comando nesta pasta: java -jar glassfish-persistence-installer-v2-bXX.jar Isto irá criar uma pasta chamada glassfish-persistence contendo o arquivo de licença, README e as bibliotecas TopLink Essentials: 3RD-PARTY-LICENSE.txt CDDLv1.0.txt READMEtoplink-essentials-agent.jartoplink-essentials.jar

  15. JPA – Java Persistence API Crie um projeto (Java5 ou superior) e adicione os arquivos .jar mencionados anteriormente, no classpath, para que se possa utilizar o Oracle TopLink. Não esqueça de adicionar também o .jar do driver JDBC. Crie a classe persistente chamada Aluno descrita abaixo: package modelo; import javax.persistence.*; @Entity public class Aluno { @Id @GeneratedValue (strategy=GenerationType.IDENTITY) private int id; private String nome; private long ra; private double ms1; private double ms2; //getters e setters omitidos }

  16. JPA – Java Persistence API Crie o arquivo persistence.xml na pasta META-INF em seu projeto. <?xml version="1.0" encoding="UTF-8"?> <persistence xmlns="http://java.sun.com/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.0" xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_1_0.xsd"> <persistence-unit name="teste"> <provider> oracle.toplink.essentials.ejb.cmp3.EntityManagerFactoryProvider </provider> <class>modelo.Aluno</class> <properties> <property name="toplink.logging.level" value="INFO" /> <property name="toplink.jdbc.driver" value="com.mysql.jdbc.Driver" />

  17. JPA – Java Persistence API <property name="toplink.jdbc.url" value="jdbc:mysql://127.0.0.1:3306/uniban" /> <property name="toplink.jdbc.user" value="root" /> <property name="toplink.jdbc.password" value="admin" /> <property name="toplink.ddl-generation" value="create-tables" /> </properties> </persistence-unit> </persistence> Crie o banco de dados de teste com o nome uniban

  18. JPA – Java Persistence API Inclusão - Crie a classe da aplicação chamada CriaAluno e a execute. package negocio; import modelo.*; import javax.persistence.*; public class CriaAluno { public static void main(String[] args) { EntityManagerFactory emf = Persistence.createEntityManagerFactory("teste"); EntityManager em = emf.createEntityManager(); em.getTransaction().begin(); Aluno a = new Aluno(); a.setNome("Maria"); a.setRa(123456789); a.setMs1(5.5); a.setMs2(4.5); em.persist(a); //Torna o objeto MANAGED em.getTransaction().commit(); em.close(); emf.close(); System.out.println("id do aluno persistido: " + a.getId()); } }

  19. JPA – Java Persistence API Implantação da Aplicação. Na pasta raiz do seu projeto, crie um arquivo texto chamado manifest.txt com o seguinte conteúdo: Main-class: CriaAluno Class-path: mysql-connector-java-5.0.6-bin.jar toplink-essentials.jar toplink-essentials-agent.jar Obs.: Deve haver um espaço em branco após os dois pontos de cada parâmetro; deve haver uma linha em branco no final do arquivo; os arquivos .jar devem ser separados por espaços em branco e devem estar numa única linha no arquivo. No prompt de comando, na pasta raiz do seu projeto, digite a seguinte linha de comando: jar cvfm teste.jar manifest.txt *.class model/*.class META-INF/* Será gerado um arquivo chamado teste.jar que contém as classes da aplicação. Copie os arquivos .jar do Oracle TopLink e o .jar do driver JDBC para a pasta onde estiver o arquivo teste.jar. Para executar a aplicação, digite a seguinte linha de comando: java -jar teste.jar

  20. JPA – Java Persistence API Automatização de deploy com o Apache Ant Baixe o Ant (arquivo: apache-ant-1.7.0-bin.zip) do site: http://ant.apache.org Descompacte o arquivo na pasta raiz do hd. Renomeie a pasta para "ant". Crie uma variável de ambiente chamada "ANT_HOME" contendo o caminho da pasta de instalação do ant: "set ANT_HOME=c:\ant" Inclua o caminho "%ANT_HOME%\bin" no path do sistema. Crie um arquivo build.xml na pasta raiz do seu projeto com o conteúdo a seguir.

  21. JPA – Java Persistence API <?xml version="1.0" encoding="iso-8859-1" ?> <project name= "teste" default= "implantaJar" > <target name="implantaJar" depends="criaJar"> <copy file="${jarFile}" todir="${deployDir}" overwrite="yes"/> </target> <target name="criaJar" depends="compila"> <jar destfile="${jarFile}" > <fileSet dir="." includes="*.class" /> <fileSet dir="./model" includes="*.class" /> <fileSet dir="./META-INF" includes="**" /> </jar> </target>

  22. JPA – Java Persistence API <target name="compila" depends="ambiente"> <javac srcdir="." destdir="."> <classpath path=" lib/toplink-essentials.jar" /> <classpath path=" lib/toplink-essentials-agent.jar" /> </javac> <javac srcdir="./model" destdir="./model"> <classpath path=" lib/toplink-essentials.jar" /> <classpath path=" lib/toplink-essentials-agent.jar" /> </javac> </target> <target name="ambiente" > <property name="jarFile" value= "./teste.jar" /> <property name="deployDir" value="." /> </target> </project>

  23. JPA – Java Persistence API Integrando o ANT com o Eclipse Selecione o menu "Project"; Selecione "properties"; Selecione "Builders"; Clique em "new"; Escolha "Ant Build"; Em "Name Buildfile" clique em xxx e selecione o arquivo de build criado anteriormente; Com o build selecionado clique no botão "up" até que o "ant build" apareça em primeiro lugar na lista.

  24. JPA – Java Persistence API • Busca – Localiza uma entidade através da chave primária. package negocio; import modelo.*; import javax.persistence.*; public class BuscaAluno { public static void main(String[] args) { EntityManagerFactory emf = Persistence.createEntityManagerFactory("teste"); EntityManager em = emf.createEntityManager(); Aluno a = em.find(Aluno.class, 3); // Retorna um objeto MANAGED if (a != null) { System.out.println("RA: " + a.getRa()); System.out.println("Nome: " + a.getNome()); //Objeto está MANAGED, porém, qualquer alteração NÃO será //refletida no banco de dados, pois não há Transação. a.setNome("Novo Nome"); } else { System.out.println("Aluno não encontrado"); } } }

  25. JPA – Java Persistence API Alteração – Localiza uma entidade através da chave primária e altera seu estado. package negocio; import modelo.*; import javax.persistence.*; public class AlteraAluno { public static void main(String[] args) { EntityManagerFactory emf = Persistence.createEntityManagerFactory("teste"); EntityManager em = emf.createEntityManager(); em.getTransaction().begin(); Aluno a = em.find(Aluno.class, 1); //Retorna um objeto MANAGED if (a != null) { a.setNome("Novo Nome"); a.setRa(987654321); a.setMs1(2.5); a.setMs2(3.5); System.out.println("id do aluno alterado: " + a.getId()); } em.getTransaction().commit(); em.close(); emf.close(); } }

  26. JPA – Java Persistence API Exclusão - Localiza uma entidade através da chave primária e a exclui. package negocio; import modelo.*; import javax.persistence.*; public class ExcluiAluno { public static void main(String[] args) { EntityManagerFactory emf = Persistence.createEntityManagerFactory("teste"); EntityManager em = emf.createEntityManager(); em.getTransaction().begin(); Aluno a = em.find(Aluno.class, 8); if (a != null) { em.remove(a); /*Objeto torna-se REMOVED, qualquer alteração não será refletida no banco de dados.*/ System.out.println("Aluno excluído: " + a.getId()); System.out.println(" " + a.getNome()); } else { System.out.println("Aluno não encontrado"); } em.getTransaction().commit(); em.close(); emf.close(); } }

  27. JPA – Java Persistence API Sincronização - Localiza uma entidade através da chave primária, encerra o EntityManager, altera o estado da entidade e a sincroniza no banco de dados. package negocio; import modelo.*; import javax.persistence.*; public class SincronizaAluno { public static void main(String[] args) { EntityManagerFactory emf = Persistence.createEntityManagerFactory("teste"); EntityManager em = emf.createEntityManager(); Aluno a = em.find(Aluno.class, 9); em.close(); if (a != null) { System.out.println("Nome: " + a.getNome()); a = mudaDados(a); em = emf.createEntityManager(); em.getTransaction().begin(); em.merge(a); //Sincroniza o estado da entidade no banco de dados em.getTransaction().commit(); System.out.println("Novo Nome: " + a.getNome()); } else { System.out.println("Aluno não encontrado"); } } private static Aluno mudaDados(Aluno a) { a.setNome("Juliana"); return a; } }

  28. JPA – Java Persistence API Consultas As consultas são criadas usando-se tanto a linguagem de consulta EJB Query Language (também chamada de JPA QL) como a SQL nativa. A EJB QL é semelhante à SQL, só que orientada a objetos e portável para diferentes implementações de bancos de dados. São executadas por meio da interface javax.persistence.Query que é muito parecida com a interface java.sql.PreparedStatement. Essa interface Query é obtida em tempo de execução a partir do gerenciador de entidade. As consultas podem ser criadas dinamicamente em tempo de execução ou pré-declaradas por meio de anotações nas classes persistentes ou através de XML.

  29. JPA – Java Persistence API Interface Query (javax.persistence.Query) Alguns Métodos List getResultList ( ) Executa uma consulta e retorna uma coleção de resultados. Object getSingleResult ( ) Executa uma consulta e retorna um único resultado. int executeUpdate ( ) Executa um comando de atualização(insert, update ou delete) e retorna o número de linhas afetadas no banco de dados. Query setMaxResults (int máximo) Define o número máximo de entidades que deve ser retornado na consulta.

  30. JPA – Java Persistence API Query setFirstResult (int início) Define o número da linha inicial que irá compor o resultado da consulta. void setParameter (String nome, Object valor) Define o valor de um parâmetro através de seu nome. Query setParameter (String nome, Date valor, TemporalType tipo) Define o valor de um parâmetro do tipo data através de seu nome. Query setParameter (int posição, Object valor) Define o valor de um parâmetro através de sua posição. Query setParameter (int posição, Date valor, TemporalType tipo) Define o valor de um parâmetro do tipo data através de sua posição.

  31. JPA – Java Persistence API • Consultas Dinâmicas São criadas pelo gerenciador de entidades através do método createQuery(). • Consulta que retorna um único resultado: try { Query consulta = em.createQuery( "Select a from Aluno a where a.ra = :ra"); consulta.setParameter("ra", 123456789); Aluno a = (Aluno) consulta.getSingleResult(); System.out.println("RA: " + a.getRa()); System.out.println("Nome: " + a.getNome()); } catch(NoResultException ex) { System.out.println("Aluno não encontrado"); } catch(NonUniqueResultException ex) { System.out.println("Mais que um resultado encontrado"); }

  32. JPA – Java Persistence API • Os parâmetros da consulta são ajustados através do método setParameter( ) e podem ser indicados através de duas formas: • Identificados, utilizando-se : (dois pontos) e um nome; Query consulta = em.createQuery( "Select a from Aluno a where a.ra = :ra and a.nome = :nome ); consulta.setParameter("ra", 123456789); consulta.setParameter("nome", "Maria"); • Seqüenciados, utilizando-se ? (interrogação) e um número sequencial. Query consulta = em.createQuery( "Select a from Aluno a where a.ra = ?1 and a.nome = ?2 ) consulta.setParameter(1, 123456789); consulta.setParameter(2, "Maria");

  33. JPA – Java Persistence API package negocio; import modelo.*; import javax.persistence.*; public class BuscaPorRA { public static void main(String[] args) { EntityManagerFactory emf = Persistence.createEntityManagerFactory("teste"); EntityManager em = emf.createEntityManager(); try { Query consulta = em.createQuery("Select a from Aluno a where a.ra = :ra"); consulta.setParameter("ra", 123456789); Aluno a = (Aluno)consulta.getSingleResult(); System.out.println("RA: " + a.getRa()); System.out.println("Nome: " + a.getNome()); } catch(NoResultException ex) { System.out.println("Aluno não encontrado"); } catch(NonUniqueResultException ex) { System.out.println("Mais que um resultado encontrado"); } em.close(); emf.close(); } } Consulta que retorna um único resultado

  34. JPA – Java Persistence API • Consulta que retorna os resultados em uma java.util.List: Query consulta = em.createQuery( "Select a from Aluno a where a.ms1 > :media"); consulta.setParameter("media", 5); List <Aluno>alunos = consulta.getResultList(); if (!alunos.isEmpty()) { for (Aluno a : alunos) { System.out.println("Nome: " + a.getNome()); } } else { System.out.println("Alunos não encontrados"); }

  35. JPA – Java Persistence API package negocio; import java.util.List; import modelo.*; import javax.persistence.*; public class ConsultaPorMedia { public static void main(String[] args) { EntityManagerFactory emf = Persistence.createEntityManagerFactory("teste"); EntityManager em = emf.createEntityManager(); Query consulta = em.createQuery( "Select a from Aluno a where a.ms1 > :media"); consulta.setParameter("media", 5); List <Aluno>alunos = consulta.getResultList(); if (!alunos.isEmpty()) { for (Aluno a : alunos) { System.out.println("Nome: " + a.getNome()); } } else { System.out.println("Alunos não encontrados"); } em.close(); emf.close(); } } Consulta que retorna uma coleção de resultados

  36. JPA – Java Persistence API • Consulta que utiliza um java.util.Date como parâmetro: Query consulta = em.createQuery( "Select a from Aluno a where a.DataMatricula = :data"); consulta.setParameter("data", new java.util.Date, TemporalType.DATE); List <Aluno>alunos = consulta.getResultList(); if (!alunos.isEmpty()) { for (Aluno a : alunos) { System.out.println("Nome: " + a.getNome()); } } else { System.out.println("Alunos não encontrados"); }

  37. JPA – Java Persistence API • Consulta com paginação de resultados: public static List getAlunos(int maximo, int inicio) { Query consulta = em.createQuery("Select a from Aluno a"); return consulta.setMaxResults(maximo). setFirstResult(inicio). getResultList(); }

  38. JPA – Java Persistence API package negocio; import modelo.*; import javax.persistence.*; import java.util.List; public class ConsultaPaginada { static EntityManagerFactory emf; static EntityManager em; public static List getAlunos(int maximo, int inicio) { Query consulta = em.createQuery("Select a from Aluno a"); return consulta.setMaxResults(maximo). setFirstResult(inicio). getResultList(); } Consulta com paginação de resultados

  39. JPA – Java Persistence API public static void main(String[] args) { emf = Persistence.createEntityManagerFactory("teste"); em = emf.createEntityManager(); int inicio = 1, maximo = 3; int pagina = 1; List <Aluno> alunos = null; do { alunos = getAlunos(maximo, inicio); if (!alunos.isEmpty()) { System.out.println("Pág. " + pagina); for (Aluno a : alunos) { System.out.println("Nome: " + a.getNome()); } } inicio += maximo; pagina++; } while (!alunos.isEmpty()); em.close(); emf.close(); } }

  40. JPA – Java Persistence API Consultas Nomeadas (Identificadas) São consultas pré-definidas na classe da entidade e podem ser reutilizadas em diferentes pontos da sua aplicação, facilitando assim sua manutenção. São declaradas através das anotações @NamedQueries(define um array de consultas nomeadas) e @NamedQuery(define uma consulta nomeada). São criadas pelo gerenciador de entidades através do método createNamedQuery(). @NamedQueries({ @NamedQuery(name = "consultaPorRA", query = "Select a from Aluno a where a.ra = :ra"), @NamedQuery(name = "consultaPorMedia", query = "Select a from Aluno a where a.ms1 > :media") }) Query consulta = em.createNamedQuery("consultaPorMedia"); consulta.setParameter("media", 5); Na entidade Na aplicação

  41. JPA – Java Persistence API Utilização de Consulta Nomeada Classe da Entidade package modelo; import javax.persistence.*; @NamedQueries( { @NamedQuery(name = "buscaPorRA", query = "Select a from Aluno a where a.ra = :ra"), @NamedQuery(name = "consultaPorMedia", query = "Select a from Aluno a" + " where (a.ms1*0.3 + a.ms2*0.7) > :media"), @NamedQuery(name = "aumentaMedia", query = "Update Aluno set ms1 = ms1 + :bonus"), }) @Entity public class Aluno { @Id @GeneratedValue(strategy=GenerationType.IDENTITY) private int id; private String nome; private long ra; private double ms1; private double ms2; // getters e setters omitidos }

  42. JPA – Java Persistence API Utilização de Consulta Nomeada Classe da Aplicação package negocio; import modelo.*; import javax.persistence.*; import java.util.List; public class ConsultaNomeada { public static void main(String[] args) { EntityManagerFactory emf = Persistence.createEntityManagerFactory("teste"); EntityManager em = emf.createEntityManager(); Query consulta = em.createNamedQuery("consultaPorMedia"); consulta.setParameter("media", 5); List <Aluno>alunos = consulta.getResultList(); if (!alunos.isEmpty()) { for (Aluno a : alunos) { System.out.println("Nome: " + a.getNome()); } } else { System.out.println("Alunos não encontrados"); } em.close(); emf.close(); } }

  43. JPA – Java Persistence API • Alterações em Lote • São criadas pelo gerenciador de entidades da mesma forma que as consultas. • Podem ser tanto dinâmicas como nomeadas. • São executadas através do método executeUpdate() que retorna o número de linhas afetadas. Query alteracao = em.createQuery( "Update Aluno set ms1 = ms1 + :bonus"); alteracao.setParameter("bonus", 0.5); int qtdAlunos = alteracao.executeUpdate();

  44. JPA – Java Persistence API package negocio; import javax.persistence.*; public class AumentaMedia { public static void main(String[] args) { EntityManagerFactory emf = Persistence.createEntityManagerFactory("teste"); EntityManager em = emf.createEntityManager(); em.getTransaction().begin(); Query alteracao = em.createQuery( "Update Aluno set ms1 = ms1 + :bonus"); alteracao.setParameter("bonus", 0.5); int qtdAlunos = alteracao.executeUpdate(); System.out.println(qtdAlunos + " Alunos bonificados"); em.getTransaction().commit(); em.close(); emf.close(); } } Alteração em lote

  45. JPA – Java Persistence API • Eventos de Retorno de Chamada Através das anotações abaixo, pode-se definir métodos que serão executados em resposta a um evento do ciclo de vida de uma entidade. • @PrePersist Define o método a ser executado logo após a uma chamada de EntityManager.persist(). • @PostPersist Define o método a ser executado após a inserção no banco de dados. • @PostLoad Define o método a ser executado após a uma chamada de EntityManager.find(), EntityManager.refresh(), ou quando uma consulta EJB QL é executada.

  46. JPA – Java Persistence API • @PreUpdate Define o método a ser executado antes do estado de uma entidade ser sincronizado com o banco de dados. • @PostUpdate Define o método a ser executado após o estado de uma entidade ser sincronizado, isso ocorre na confirmação de uma transação, após uma chamada a EntityManager.flush() ou sempre que o contexto de persistência atualizar o banco de dados. • @PreRemove Define o método a ser executado após a uma chamada de EntityManager.remove(). • @PostRemove Define o método a ser executado após a exclusão no banco de dados ser efetivada. Pesquise também sobre Ouvintes de entidade.

  47. JPA – Java Persistence API package modelo; import java.io.*; import java.util.Date; import javax.persistence.*; @Entity public class Aluno { ... @PrePersist void prePersist() { try { FileOutputStream fos = new FileOutputStream("log.txt", true); String linha = "Aluno " + getNome() + " gravado em " + new Date() + "\n"; fos.write(linha.getBytes()); fos.close(); fos.close(); } catch (IOException e) { e.printStackTrace(); } } } Exemplo de Arquivo de Log

  48. JPA – Java Persistence API • Exemplo de Aplicação Swing com JPA

More Related