Java persintence api

2.612 visualizações

Publicada em

0 comentários
3 gostaram
Estatísticas
Notas
  • Seja o primeiro a comentar

Sem downloads
Visualizações
Visualizações totais
2.612
No SlideShare
0
A partir de incorporações
0
Número de incorporações
2
Ações
Compartilhamentos
0
Downloads
117
Comentários
0
Gostaram
3
Incorporações 0
Nenhuma incorporação

Nenhuma nota no slide

Java persintence api

  1. 1. [ Java Persintence API ] Simplificando a Persistência de Objetos Autor: Eduardo R. Carvalho email: ercarval@gmail.com7/10/2008 Java Persistence API
  2. 2. Agenda ● Requerimentos para o JPA ● Modelo de Codificação do JPA ● Ciclo de Vida do Entity & Entity Manager ● Detached Entities ● Relacionamento entre os Entity ● Mapeamento Objeto Relacional ● Entity Listeners ● Query ● Transações ● Objetos Embutidos ● Chaves Primárias Compostas7/10/2008 Java Persistence API
  3. 3. Agenda ● JPA Overview ● Entities ● Packaging ● EntityManager ● Java EE no Mundo Java SE ● JPQL7/10/2008 Java Persistence API
  4. 4. Requisitos do JPA ● Simplificação do Modelo de Persistência ○ Eliminação da Necessidade de Descritores para Deploy ● Modelo de Persistência Leve ○ Padronizando os Frameworks de O/R ● Testavel fora do Container ○ Possibilidade da Criação de Testes utilizando os Entities sem a necessidade de um Container ● Possibilidade de Utilização de Herança e Polimorfismo ● Mapeamento Objeto Relacional ● Extensa Capacidade de Quering7/10/2008 Java Persistence API
  5. 5. JPA Comum em JSE e JEE ● A API de persistência foi expandida para que também fosse utilizada sem a necessidade de um Container EJB ○ Ela pode ser utilizada em Ambientes JSE, Web e em Aplicações EJB. ● Suporte a implementações de Fornecedores ○ Através do persistence.xml7/10/2008 Java Persistence API
  6. 6. Agenda ● JPA Overview ● Entities ● Packaging ● EntityManager ● Java EE no Mundo Java SE ● JPQL7/10/2008 Java Persistence API
  7. 7. Entity - Característica ● Entity nada mais é do que uma Classe Java que representa um Entidade de Negócio, também conhecido como um POJO (Plain Old Java Object) ● Todo entity possui um id. ● Não há necessidade de implementação de interfaces ● Suporte total a Herança e Polimorfismo ● Serializavel, não havendo a necessidade da criação de DTOs, para Uso de Clientes Remotos ou transferencia entre camadas. ● Suporte a estados não persistentes e persistentes ○ Tipos Simples (primitivos, Wrappers, enums) ○ Objetos Compostos, Composições e Agregações (Ex. Address) ○ Objetos não persistentes, sem estado de persistência (transient) ● Utilização de Anotações do JSE57/10/2008 Java Persistence API
  8. 8. POJO x Entity POJO 1. public class BankAccount { 2. private Long id; 3. private String accountName; 4. private BigDecimal balance; 5. } Entity Simples ( “ Um POJO promovido ” ) 6. @Entity 7. public class BankAccount { 8. @Id 9. private Long id; 10. private String accountName; 11. private BigDecimal balance; 12. } A Classe é mapeada a Tabela e os atributos são mapeados as colunas7/10/2008 Java Persistence API
  9. 9. @Table 1. @Entity 2. @Table(name="BANK_ACCOUNT") 3. public class BankAccount { 4. @Id 5. private Long id; 6. private String accountName; 7. private BigDecimal balance; 8. }7/10/2008 Java Persistence API
  10. 10. @Version 1. @Entity 2. @Table(name="BANK_ACCOUNT") 3. public class BankAccount { 4. @Id 5. private Long id; 6. @Version 7. private Long version; 8. private String accountName; 9. private BigDecimal balance; 10. } Utilização de Lock Otimista através da Anotação Version7/10/2008 Java Persistence API
  11. 11. @Column 1. @Entity 2. @Table(name="BANK_ACCOUNT") 3. public class BankAccount { 4. @Id 5. private Long id; 6. @Version 7. private Long version; 8. @Column(name="ACCOUNT_NAME") 9. private String accountName; 10. private BigDecimal balance; 11. } ● A Annotation Column permite que você defina o nome da coluna , tamanho , precisão, escala, etc.7/10/2008 Java Persistence API
  12. 12. @Lob 1. @Entity 2. @Table(name="BANK_ACCOUNT") 3. publicclass BankAccount { 4. @Id 5. private Long id; 6. @Version 7. private Long version; 8. @Column(name="ACCOUNT_NAME") 9. private String accountName; 10. private BigDecimal balance; 11. @Lob 12. private String description; 13. } ● A Configuração de Tamanho de um Atributo/Propriedade String padrão é de 255.7/10/2008 Java Persistence API
  13. 13. @Enumerated 1. @Entity 2. @Table(name="BANK_ACCOUNT") 3. public class BankAccount { 4. @Id 5. private Long id; 6. // ... 7. @Enumerated(EnumType.ORDINAL) 8. private AccountStatus status; 9. } 10. public enum AccountStatus { 11. PENDING, APPROVED, ACTIVE; 12. } A Annotation Enumerated Define dois tipos de Enumeration, EnumType : public enum EnumType {ORDINAL, STRING}7/10/2008 Java Persistence API
  14. 14. @Temporal 1. @Entity 2. @Table(name="BANK_ACCOUNT") 3. public class BankAccount { 4. @Id 5. //... 6. @Enumerated(EnumType.ORDINAL) 7. private AccountStatus status; 8. @Temporal(TemporalType.TIMESTAMP) 9. private Date dateCreated; 10. } ● A Annotation TemporalType Define alguns tipos Temporais através da enum : public enum TemporalType {DATE, TIME, TIMESTAMP}7/10/2008 Java Persistence API
  15. 15. @Transient 1. @Entity 2. @Table(name="BANK_ACCOUNT") 3. public class BankAccount { 4. @Id 5. //... 6. @Enumerated(EnumType.ORDINAL) 7. private AccountStatus status; 8. @Temporal(TemporalType.TIMESTAMP) 9. private Date dateCreated; 10. @Transient 11. private BigDecimal calculatedValue; 12. } ● Assim com em classes Serializadas a Annotation Transient indica que o atributo não será persistido.7/10/2008 Java Persistence API
  16. 16. Modificador transient 1. @Entity 2. @Table(name="BANK_ACCOUNT") 3. publicclass BankAccount { 4. @Id 5. //... 6. @Enumerated(EnumType.ORDINAL) 7. private AccountStatus status; 8. @Temporal(TemporalType.TIMESTAMP) 9. private Date dateCreated; 10. private transient BigDecimal calculatedValue; 11. } ● O Modificador transiente tem a mesma finalidade para os Entities, informar que a o atributo não será Serializado7/10/2008 Java Persistence API
  17. 17. Entity Identification ● A Especificação do JPA exige que todos os Entities informem um Id. Este pode ser um Atributo simples, um tipo definido pelo usuário. Sendo o primeiro um mapeamento para uma coluna no banco de dados representando uma chave primaria. O Segundo uma determinação de chave composta, ou seja múltiplas colunas no banco de dados.7/10/2008 Java Persistence API
  18. 18. Persistent ID ● @Id – Define a chave primaria a um atributo ou propriedade ● @EmbeddedId – Mapeia um Entity a um Atributo/Propriedade ● @IdClass – Mapear multiplos atributos / propriedades, para compor uma chave primaria composta. ● Classes que representam chaves primarias7/10/2008 Java Persistence API
  19. 19. Chave Primária Simples 1. @Entity 2. public class BankAccount { 3. @Id 4. private Long id; 5. // ... 6. }7/10/2008 Java Persistence API
  20. 20. Chaves Compostas 1º. Adicione a Annotation @IdClass 2º. Crie a Classe de que representa em BankAccount a Chave (POJO) 1. @Entity 1. public class BankAccountKey 2. @Table(name="BANK_ACCOUNT") 2. implements Serializable { 3. @IdClass(BankAccountKey.class) 3. private Long id; 4. public class BankAccount { 4. private Long secondId; 5. @Id 5. } 6. private Long id; 7. @Id 8. private Long secondId; 9. }7/10/2008 Java Persistence API
  21. 21. Chaves Compostas 2º. Crie a Classe de que representa 1º. Adicione a a Chave (POJO) e Adicione a Annotation Annotation @Embeddable @EmbeddedId em 1. @Embeddable BankAccount 2. public class BankAccountKey 3. implements Serializable { 4. private Long id; 5. private Long secondId; 1. @Entity 6. } 2. @Table(name=" BANK_ACCOUNT") 3. public class BankAccount { 4. @EmbeddedId 5. private BankAccountKey id; 6. }7/10/2008 Java Persistence API
  22. 22. Geração de Chaves Primárias ● Use @GeneratedValue para definir a geração da Chave Primaria ● Estratégias de Geração Disponíveis 1. public enum GenerationType { 2. TABLE, SEQUENCE, IDENTITY, AUTO 3. }; ● De preferência ao Tipo AUTO sempre que possível, visando a portabilidade.7/10/2008 Java Persistence API
  23. 23. Relacionamentos com JPA ● Suporte a Composição e Agregação ● Relacionamentos do Tipo : one-to-one, one-to-many, many-to-one, many-to-many ● Relacionamento unidirecionais e bidirecionais ● Relacionamentos bidirecionais são administrados pela aplicação e não pelo provedor de persistência (persistence provider). ● Em um relacionamento bidirecional não há um proprietário, mas sim um referencia cruzada entre eles.7/10/2008 Java Persistence API
  24. 24. Relacionamentos Bidirecionais User 1 1 Address user address 1. @Entity 2. @Table(name="address") 3. public class Address { address 4. @Id 5. private Integer id; id streetAddress user_id 6. @OneToOne 7. private User user; 8. private String streetAddress; 9. } 10. @Entity 11. public class User { 12. @Id 13. private Integer id; 14. @OneToOne(cascade=CascadeType.ALL, mappedBy="user") 15. private Address address; 16. }7/10/2008 Java Persistence API
  25. 25. Gerenciamento de Relacionamentos User 1 1 Address user address 1. @Entity 2. public class User { 3. @Id 4. private Integer id; 5. @OneToOne(cascade=CascadeType.ALL, 6. mappedBy="user") 7. private Address address; 8. public void setAddress(Address address) { 9. this.address = address; 10. address.setUser (this); 11. } 12. }7/10/2008 Java Persistence API
  26. 26. Composição ● O Relacionamento de Composição define um relacionamento forte entre dois objetos, sendo um o proprietário do outro e o responsável pelo ciclo de vida deste objeto. ● Use a Annotation @Embedded e @Embeddable para determinar o relacionamento de composição ● Deteminar a Separação Logica entre os Entities ● Ambos os Entities serão persistidos na mesma tabela7/10/2008 Java Persistence API
  27. 27. Composição @Embeddable public class UserDetail { @Entity private String firstName; @Table(name="user") private String lastName; public class User { } @Embedded private UserDetail userDetail; private String username; private String password; }7/10/2008 Java Persistence API
  28. 28. Agregação ● O Relacionamento de Agregação define que existe um relacionamento entre as partes. Mas não há um proprietário e cada um é responsável pelo seu próprio ciclo de vida, pode estar associado a outras entidades. ● As Annotations @ManyToOne, @OneToMany, @ManyToMany e @OneToOne definem o uso de Agregação entre Entities.7/10/2008 Java Persistence API
  29. 29. Cascade & FetchType ● JPA prove suporte a operações do tipo Cascade, através do enum CascadeType public enum CascadeType { ALL, PERSIST, MERGE, REMOVE, REFRESH }; ● JPA também possui suporte a carregamento tardio (Lazy) e eager fetching para relacionamentos public enum FetchType { LAZY, EAGER };7/10/2008 Java Persistence API
  30. 30. Many-to-One ● A Annotation @ManyToOne é utilizada relacionamentos de muitos para um. ● Deve ser utilizada para representar o objeto de referencia ● A Annotation @JoinColumn é utilizada para chaves estrangeiras7/10/2008 Java Persistence API
  31. 31. Many-to-One @Entity public class BankAccount implements Serializable { // ... @ManyToOne(optional=false, fetch=FetchType.LAZY) @JoinColumn(name="created_by_user_id") private User createdBy; } * O Elemento optional indica que a coluna pode ser nula ou não7/10/2008 Java Persistence API
  32. 32. One-to-Many ● Use a Annotation @OneToMany para determinar o um Relacionamento de Um Para Muitos, não sendo ela a proprietária pelo relacionamento. ● A Associação do tipo one-to-many representa uma Coleção de Obejtos. ● Use @JoinColumn para definir chaves estrangeiras ● A Annotation @OrderBy é utilizada para7/10/2008 Java Persistence API
  33. 33. One-to-Many 1. @Entity 2. @Table(name="user") 3. public class User { 4. @OneToMany(mappedBy="createdBy") 5. @OrderBy("dateCreated DESC") 6. private List<BankAccount> accounts; 7. } ● A Tabela BankAccount contém a chave estrangeira created_by_user_id ● A annotation @OneToMany não possui elementos opcionais, pois não é proprietário do dado.7/10/2008 Java Persistence API
  34. 34. Many-to-Many ● Use a Annotation @ManyToMany em ambos os lados do relacionamento para representar coleções de dados em ambos os lados. ● Ambos os lados são proprietarios do dado ● Use a annotation @JoinTable no lado proprietário para determinar a tabela de ligação. ● Compartilha os mesmos elementos de @OneToMany7/10/2008 Java Persistence API
  35. 35. Many-to-Many @Entity public class Role { @ManyToMany(cascade=CascadeType.ALL, fetch=FetchType.LAZY) @JoinTable( name = "user_role", joinColumns = @JoinColumn( name = "user_id", referencedColumnName = "id"), inverseJoinColumns = @JoinColumn( name = "role_id", referencedColumnName = "id") ) protected Set<User> users = new HashSet<User>(); }7/10/2008 Java Persistence API
  36. 36. One-to-One User 1 1 Address user address ● Utiliza a Annotation @OneToOne em ambos os lados do relacionamento ● Não Existe um proprietário pelo relacionamento, ambos os lados são responsáveis por este. ● Compartilha os mesmos elementos de @ManyToOne7/10/2008 Java Persistence API
  37. 37. Herança7/10/2008 Java Persistence API
  38. 38. Herança ● JPA tem total suporte a herança através das annotations @MappedSuperclass e @Inheritance ● Suporte a um modelo híbrido, pois é possível mesclar em sua hierarquia de classes , Entities e Não-Entities, classes concretas e abstratas ● Use @MappedSuperclass para determinar atributos comuns no modelo ● Use @Inheritance determinar7/10/2008 Java Persistence API
  39. 39. @MappedSuperclass7/10/2008 Java Persistence API
  40. 40. MappedSuperclass7/10/2008 Java Persistence API
  41. 41. @MappedSuperclass 1. @MappedSuperclass 2. public abstract class ModelBase { 3. @Id 4. private Integer id; 5. @Version 6. private Integer version; 7. } 8. @Entity 9. public class User extends ModelBase { 10. @Column(name="USER_NAME") 11. private String username; 12. } 13. @Entity 14. public class BankAccount extends ModelBase { 15. private String accountName; 16. }7/10/2008 Java Persistence API
  42. 42. @Inheritance7/10/2008 Java Persistence API
  43. 43. @Inheritance ● Os Entities podem conter subclasses ○ Classe NON-Entity Concreta ou Abstrata ○ Classe Entity Concreta ou Abstrata ● A Especificação do JPA suporta Três Estratégias de Herança para Entities ○ SINGLE_TABLE: Uma Tabela para toda Hierarquia ○ JOINED : Cada Entity (Concreto ou Abstrato) na Hierarquia representa uma tabela. ○ TABLE_PER_CLASS: (Opcional) Uma7/10/2008 Tabela por Classe Concreta. Java Persistence API
  44. 44. SINGLE_TABLE 1. @Entity 2. @Inheritance(strategy=SINGLE_TABLE) 3. @DiscriminatorColumn(name="type", 4. discriminatorType=STRING) 5. public abstract class Rank { 6. ... 7. protected String rankName; 8. protected String avatar ; 9. } 10. @Entity 11. @DiscriminatorValue("SPECIAL_RANK") 12. public class SpecialRank 13. extends Rank { 14. protected String message; RANK 15. } Id Type RankName Avatar Message minimumPostCount 16. @Entity 1 POST_CO firstRank Junior 5 UNT .jpg 17. @DiscriminatorValue("POST_COUNT") 2 SPECIAL Newbie New. New 18. public class PostCountRank _RANK jpg member 19. extends Rank { 20. protected 21. Integer minumumPostCount; 22. }7/10/2008 Java Persistence API
  45. 45. JOINED 1. @Entity 2. @Inheritance(strategy=JOINED) 3. public abstract class Rank { 4. protected String rankName; 5. protected String avatar; 6. } 7. @Entity RANK 8. public class SpecialRank Id RankName Avatar 9. extends Rank { 1 firstRank Junior.jpg 10. protected String message; 2 Newbie New.jpg 11. } PostCountRANK 12. @Entity SpecialRANK Id minimumPostCount 13. public class PostCountRank Id Message Newbie Newbie 1 2 14. extends Rank { 15. protected Integer minimumPostCount; 16. }7/10/2008 Java Persistence API
  46. 46. TABLE_PER_CLASS 1. @Entity 2. @Inheritance(strategy=TABLE_PER_CLASS) 3. public abstract class Rank { 4. @Id @GeneratedValue( 5. strategy=GenerationType.TABLE) 6. private Long id; 7. } 8. @Entity 9. public class SpecialRank SPECIALRANK 10. extends Rank { Id Type RankName Avatar Message 11. protected String message; 12. } 1 POST_CO firstRank Junior UNT .jpg 2 SPECIAL Newbie New. New 13. @Entity _RANK jpg member 14. public class PostCountRank 15. extends Rank { 16. protected POSTCOUNTRANK 17. Integer minimumPostCount; Id Type RankN Avatar minimumPost ame Count 18. } 1 POST_ firstR Junior. 5 COUNT ank jpg 2 SPECI Newbie New.jpg AL_RA NK7/10/2008 Java Persistence API
  47. 47. Agenda ● JPA Overview ● Entities ● Packaging ● EntityManager ● Java EE no Mundo Java SE ● JPQL7/10/2008 Java Persistence API
  48. 48. Packaging O Único XML necessário7/10/2008 Java Persistence API
  49. 49. Empacote seus Entities ● A Especificação de JPA necessita de um único XML de configuração, este fica no diretório ○ META-INF/persistence.xml ○ Define o nome do unidade de persistencia (persistence unit) ○ Determina Estratégia de Transação para o EntityManager ○ Identifica os Entities que estão contidos na unidade de persistencia ○ Define as Configurações do provedor de persistencia ● Você também pode criar o arquivo de mapeamento objeto-relacional ○ Ele é muito parecido com o .hbm.xml do Hibernate ○ Pode ser alterado, ou sobrescrever as annotations ○ Ele é Identificado como persistence.xml7/10/2008 Java Persistence API
  50. 50. persistence.xml <persistence ...> <persistence-unit name="djbug" transaction-type="RESOURCE_LOCAL"> <provider> org.hibernate.ejb.HibernatePersistence </provider> <mapping-file>META-INF/orm-mapping.xml</mapping-file> <class>org.ujug.jpa.model.BankAccount</class> <properties> <property name="hibernate.show_sql" value="false" /> </properties> </persistence-unit> </persistence> ● transaction-type pode ser configurado como : ○ JTA ○ RESOURCE_LOCAL7/10/2008 Java Persistence API
  51. 51. Terminologia JPA ● Persistence Unit (Unidade de Persistencia) : Nome Lógico dado a um grupo de Entities, definidos usando o elemento persistence-unit em persistence.xml ○ <persistence-unit name="djbug" ... > ● Persistence Context – O nome dado a uma Coleção de Entities em tempo de execução, gerenciados pelo EntityManager7/10/2008 Java Persistence API
  52. 52. Agenda ● JPA Overview ● Entities ● Packaging ● EntityManager ● Java EE no Mundo Java SE ● JPQL7/10/2008 Java Persistence API
  53. 53. EntityManager7/10/2008 Java Persistence API
  54. 54. EntityManager ● Principal diferença entre JSE e JEE é a utilização do EntityManager ● Muito similar a inteface Session do Hibernate ● Ele que prove a acesso ao Persistence Context ● Prove Serviços do tipo CRUD persist, remove, find, merge, etc. ● Prove Interface para Transaction API ● Factory para a API de Query.7/10/2008 Java Persistence API
  55. 55. EM & Persistence Context ● São segregados em dois tipos ○ Gerenciados pelo Container ( JEE ) através da annotation @PersistenceCotext ○ Gerenciada pela Aplicação (JSE/JEE) através do EntityManagerFactory para recuperar a referencia, fica a cargo da aplicação a responsabilidade sobre a gestão do ciclo de vida do EntityManager ● Dois tipos de Contexto de Persistencia ○ Transacional7/10/2008 ○ Entendido (extended persistence context) Java Persistence API
  56. 56. EM – Gerenciado pelo Container ● Escopo de Transação gerenciado pelo container através do persistence.xml <persistence-unit ... transaction-type=" JTA"> @PersistenceContext(type=TRANSACTION) protected EntityManager entityManager; @PersistenceContext(type=EXTENDED) protected EntityManager entityManager;7/10/2008 Java Persistence API
  57. 57. EM – Gerenciado pela Aplicação ● Pode ser utilizado tanto em ambientes JSE quanto em JEE ● Necessidade de finalizar o EM. ● Fica a cargo da Aplicação determinar a utilização de transações ● EM é provido pelo EntityManagerFactory ● Utiliza ExtendedPersistenceContext, devido a determinação do ciclo de vida do EM delegado a aplicação.7/10/2008 Java Persistence API
  58. 58. EM – Gerenciado pela Aplicação ● No ambiente JEE pode ser utilizado a annotation @PersitenceUnit @PersistenceUnit EntityManagerFactory emf; ● No ambiente JSE é necessário a utilização da classe Persistence EntityManagerFactory emf = Persistence.createEntityManagerFactory(“season");7/10/2008 Java Persistence API
  59. 59. EM – Gerenciado pela Aplicação@PersistenceUnitEntityManagerFactory emf;public User createUser(String username, String password, String email){User u = null;EntityManager em = emf.createEntityManager();try {u = new User();u.setUsername(username);u.setPassword(password);u.getUserDetail().setEmailAddress(email);em.getTransaction().begin();em.persist(u);em.getTransaction().commit();} finally {em.close();}return u;} // @PersistenceUnit7/10/2008 é aplicávelJava Persistence API containers JEE 5 somente a
  60. 60. EM – Gerenciado pela Aplicação public User createUser(String username, String password, String email) { User u = null; EntityManagerFactory emf = Persistence.createEntityManagerFactory("ujug"); EntityManager em = emf.createEntityManager(); try { u = new User(); u.setUsername(username); u.setPassword(password); u.getUserDetail().setEmailAddress(email); em.getTransaction().begin(); em.persist(u); em.getTransaction().commit(); } finally { em.close(); emf.close(); } return u; }7/10/2008 Java Persistence API
  61. 61. Métodos de Callback e Listeners ● Os métodos de callback são determinados nos entities e classes no-entities ○ void methodName() ○ void methodName (Object entity) ● Métodos de callback/listeners são registrados de acordo com as annotations abaixo ● @PrePersist/@PostPersist ● @PreUpdate/@PostUpdate – persistence provider dependent ● @PreRemove/@PostRemove ● @PostLoad7/10/2008 Java Persistence API
  62. 62. Métodos de Callback e Listeners 1. // Para Registrar um callback basta criar um metodo e 2. // adicionar uma annotation de ciclo de vida. 3. @MappedSuperclass 4. public abstract class ModelBase { 5. @PrePersist 6. public void setDates() { 7. Date now = new Date(); 8. if (dateCreated == null) { 9. dateCreated = now; 10. } 11. dateUpdated = now; 12. } 13. }7/10/2008 Java Persistence API
  63. 63. Registrando a Classe de Listener ● Utilizando um Listener @MappedSuperclass @EntityListeners({ModelListener.class}) public abstract class ModelBase { // fields and methods removed for readability } ● Implementando um Listener public class ModelListener { @PrePersist public void setDates(ModelBase modelBase) { Date now = new Date(); if (modelBase.getDateCreated() == null) modelBase.setDateCreated(now); modelBase.setDateUpdated(now); } }7/10/2008 Java Persistence API
  64. 64. Agenda ● JPA Overview ● Entities ● Packaging ● EntityManager ● Java EE no Mundo Java SE ● JPQL7/10/2008 Java Persistence API
  65. 65. Java EE no Java SE Provido por Spring7/10/2008 Java Persistence API
  66. 66. Use Spring como Ponte para JEE ● Utilizar o suporte JPA provido pelo Spring ● Spring provê integração com JPA , implementando as responsabilidades do Container ● Utiliza os Provedores de Persistencia (Hibernate,TopLink) ● Habilita Annotations @PersistenceContext em aplicações JSE ● Para mais informações acesse a documentação do Spring 2.07/10/2008 Java Persistence API
  67. 67. Agenda ● JPA Overview ● Entities ● Packaging ● EntityManager ● Java EE no Mundo Java SE ● JPQL7/10/2008 Java Persistence API
  68. 68. JPQL Aceita SQL ??7/10/2008 Java Persistence API
  69. 69. JPQL - Visão Geral ● Independente de Banco de Dados ● Suporte a projeção para classe no-entity ● Suporte a funções de agregação ex. max , min, avg, etc. ● Suporte a Atualizações em Lote update e delete ● Suporte a subquery ● Suporte a inner e outer joins ● Suporte a queries dinâmicas e estáticas (named) ● Sintaxe JPQL semelhante a SQL ■ select from [where] [group by] [having] [order7/10/2008 by] Java Persistence API
  70. 70. Query API ● Utiliza o EntityManager para obter a instancia do Objeto Query Query q = em.createQuery(“query string”); ● API de Query permite: ○ Controle de paginação ○ Definir Maximo de resultados retornados ○ Utilização de nome da definição de parâmetros para as queries ou por posição7/10/2008 Java Persistence API
  71. 71. Criando uma Query ● EntityManager query related methods: public Query createQuery(String qlString); public Query createNamedQuery(String name); public Query createNativeQuery(String sqlString); public Query createNativeQuery(String sqlString, Class resultClass); public Query createNativeQuery(String sqlString, String resultSetMapping); @PersistenceContext protected EntityManager entityManager; public List findAll() { Query q = entityManager.createQuery("select user from User u"); return q.getResultList(); }7/10/2008 Java Persistence API
  72. 72. Queries Estáticas e Dinâmicas ● Queries Estaticas são definidas através das Annotation @NamedQuery e retornadas através do metodo ○ EntityManager.createNamedQuery() ● Queries Dinamicas são definidas através do metodo ○ EntityManager.createQuery() ● Tanto as Queries Estaticas quanto queries Dinamicas podem utilizar Query Pre-Compiladas7/10/2008 Java Persistence API
  73. 73. Exemplo de Query Dinamica 1. Query q = em.createQuery("SELECT u FROM User u " + 2. “WHERE u.username = ?1"); 3. q.setParameter(1, "mac"); 4. q.setFirstResult(10); // numbered from 0 5. q.setMaxResults(10); // only fetch 10 6. List results = q.getResultList();7/10/2008 Java Persistence API
  74. 74. Exemplo de Query Estatica ● Definindo query: ● @Entity ● @NamedQuery(name="user.updatedAtIP", query="select u ● from User u where u.updatedAtIP like :ip") ● public class User extends ModelBase { ● // removed for readibility... ●} ● Utilizando a Query acima: ● Query q = em.createNamedQuery("user.updatedAtIP"); ● q.setParameter("ip", "127.0.0.1"); ● q.setFirstResult(9); // numbered from 0 ● q.setMaxResults(10); // only fetch 10 ● List results = q.getResultList();7/10/2008 Java Persistence API
  75. 75. Navegando no Objeto ● Suporte a navegação entre os entities relacionados na clausula Select, utilizando o operador (.) para acessar atributos simples, não coleções. ○ select p.toUser.userIPAddresses from PrivateMessage p ● Utilize a palavra Chave join para acessar atributos definidos em coleções ○ select r.name from User u join u.roles r7/10/2008 Java Persistence API
  76. 76. Bibliografia ● EJB 3.0 In Action ○ [ISBN : 1-933988-34-7] ● JPA 101: Java Persistence Explained ○ [ISBN : 0-9765534-1-4]7/10/2008 Java Persistence API

×