java persintence api

7/10/2008 Java Persistence API

Autor: Eduardo R. Carvalhoemail: [email protected]

[ Java Persintence API ]

Simplificando a Persistência de Objetos


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 Compostas


Agenda

●JPA Overview●Entities●Packaging●EntityManager● Java EE no Mundo Java SE● JPQL


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 Quering


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.xml


Agenda

● JPA Overview●Entities●Packaging●EntityManager● Java EE no Mundo Java SE● JPQL


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 JSE5


POJO x Entity

POJO1. public class BankAccount {2. private Long id;3. private String accountName;4. private BigDecimal balance;5. }

Entity Simples ( “ Um POJO promovido ” )

6. @Entity7. public class BankAccount {8. @Id9. private Long id;

10. private String accountName;11. private BigDecimal balance;12. }

A Classe é mapeada a Tabela e os atributos são mapeados as colunas


@Table

1. @Entity2. @Table(name="BANK_ACCOUNT")3. public class BankAccount {4. @Id5. private Long id;6. private String accountName;7. private BigDecimal balance;8. }


@Version

1. @Entity2. @Table(name="BANK_ACCOUNT")3. public class BankAccount {4. @Id5. private Long id;6. @Version7. private Long version; 8. private String accountName;9. private BigDecimal balance;

10. }

Utilização de Lock Otimista através da Anotação Version


@Column

1. @Entity2. @Table(name="BANK_ACCOUNT")3. public class BankAccount {4. @Id5. private Long id;6. @Version7. 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.


@Lob

1. @Entity2. @Table(name="BANK_ACCOUNT")3. publicclass BankAccount {4. @Id5. private Long id;6. @Version7. private Long version;8. @Column(name="ACCOUNT_NAME")9. private String accountName;

10. private BigDecimal balance;11. @Lob12. private String description;13. }

● A Configuração de Tamanho de um Atributo/Propriedade String padrão é de 255.


@Enumerated

1. @Entity2. @Table(name="BANK_ACCOUNT")3. public class BankAccount {4. @Id5. 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}


@Temporal

1. @Entity2. @Table(name="BANK_ACCOUNT")3. public class BankAccount {4. @Id5. //...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}


@Transient

1. @Entity2. @Table(name="BANK_ACCOUNT")3. public class BankAccount {4. @Id5. //...6. @Enumerated(EnumType.ORDINAL)7. private AccountStatus status;8. @Temporal(TemporalType.TIMESTAMP)9. private Date dateCreated;

10. @Transient11. private BigDecimal calculatedValue;12. }

● Assim com em classes Serializadas a Annotation Transient indica que o atributo não será persistido.


Modificador transient

1. @Entity2. @Table(name="BANK_ACCOUNT")3. publicclass BankAccount {4. @Id5. //...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á Serializado


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.


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 primarias necessitam implementar Serializable


Chave Primária Simples

1. @Entity2. public class BankAccount {3. @Id4. private Long id;5. // ...6. }


Chaves Compostas

1º. Adicione a Annotation @IdClass em BankAccount

1. @Entity2. @Table(name="BANK_ACCOUNT")3. @IdClass(BankAccountKey.class)4. public class BankAccount {5. @Id6. private Long id;7. @Id8. private Long secondId;9. }

2º. Crie a Classe de que representa a Chave (POJO)

1. public class BankAccountKey2. implements Serializable {3. private Long id;4. private Long secondId;5. }


Chaves Compostas

1º. Adicione a Annotation @EmbeddedId em BankAccount

1. @Entity2. @Table(name="BANK_ACCOUNT")

3. public class BankAccount {

4. @EmbeddedId5. private BankAccountKey id;

6. }

2º. Crie a Classe de que representa a Chave (POJO) e Adicione a Annotation @Embeddable

1. @Embeddable2. public class BankAccountKey3. implements Serializable {4. private Long id;5. private Long secondId;6. }


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, AUTO3. };

●De preferência ao Tipo AUTO sempre que possível, visando a portabilidade.


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.


Relacionamentos Bidirecionais

1. @Entity2. @Table(name="address")3. public class Address {4. @Id5. private Integer id;6. @OneToOne7. private User user;8. private String streetAddress;9. }

10. @Entity11. public class User {12. @Id13. private Integer id;14. @OneToOne(cascade=CascadeType.ALL, mappedBy="user")15. private Address address;16. }

User Address1 1

streetAddress user_ididaddress

user address


Gerenciamento de Relacionamentos

1. @Entity2. public class User {3. @Id4. 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. }

User Address1 1user address


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 tabela

de banco de dados.


Composição

@Entity@Table(name="user")public class User {@Embeddedprivate UserDetail userDetail;private String username;private String password;}

@Embeddablepublic class UserDetail {private String firstName;private String lastName;}


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.


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 };


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 estrangeiras


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ão


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 para determinar a ordem da coleção.


One-to-Many

1. @Entity2. @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.


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 @OneToMany


Many-to-Many

@Entitypublic 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>();}


One-to-One

● 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 @ManyToOne

User Address1 1user address


Herança


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 determinar hierarquia de herança.


@MappedSuperclass


MappedSuperclass


@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. @Entity14. public class BankAccount extends ModelBase {15. private String accountName;16. }


@Inheritance


@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) Uma Tabela por Classe Concreta.


SINGLE_TABLE1. @Entity2. @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. @Entity11. @DiscriminatorValue("SPECIAL_RANK")12. public class SpecialRank13. extends Rank {14. protected String message;15. }

16. @Entity17. @DiscriminatorValue("POST_COUNT")18. public class PostCountRank 19. extends Rank {20. protected 21. Integer minumumPostCount;22. }

New member

New.jpg

NewbieSPECIAL_RANK

2

5Junior.jpg

firstRankPOST_COUNT

1

minimumPostCountMessageAvatarRankNameTypeId

RANK


JOINED

1. @Entity2. @Inheritance(strategy=JOINED)3. public abstract class Rank {4. protected String rankName;5. protected String avatar;6. }

7. @Entity8. public class SpecialRank 9. extends Rank {

10. protected String message;11. }

12. @Entity13. public class PostCountRank 14. extends Rank {15. protected Integer minimumPostCount;16. }

New.jpgNewbie2

Junior.jpgfirstRank1

AvatarRankNameId

RANK

Newbie2

MessageId

SpecialRANK

Newbie1

minimumPostCountId

PostCountRANK


TABLE_PER_CLASS1. @Entity2. @Inheritance(strategy=TABLE_PER_CLASS)3. public abstract class Rank {4. @Id @GeneratedValue(5. strategy=GenerationType.TABLE)6. private Long id;7. }8. @Entity9. public class SpecialRank

10. extends Rank {11. protected String message;12. }

13. @Entity14. public class PostCountRank 15. extends Rank {16. protected 17. Integer minimumPostCount;18. }

New member

New.jpg

NewbieSPECIAL_RANK

2

Junior.jpg

firstRankPOST_COUNT

1

MessageAvatarRankNameTypeId

SPECIALRANK

New.jpgNewbieSPECIAL_RANK

2

5Junior.jpg

firstRank

POST_COUNT

1

minimumPostCount

AvatarRankName

TypeId

POSTCOUNTRANK


Agenda



PackagingO Único XML necessário


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.xml


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_LOCAL


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 EntityManager


Agenda



EntityManager


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.


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○ Transacional○ Entendido (extended persistence context)


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;


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.



●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");


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;}

// @PersistenceUnit é aplicável somente a containers JEE 5



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;}


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● @PostLoad


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. @MappedSuperclass4. public abstract class ModelBase {5. @PrePersist6. public void setDates() {7. Date now = new Date();8. if (dateCreated == null) {9. dateCreated = now;

10. }11. dateUpdated = now;12. }13. }


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 {@PrePersistpublic void setDates(ModelBase modelBase) {Date now = new Date();if (modelBase.getDateCreated() == null)modelBase.setDateCreated(now);modelBase.setDateUpdated(now);} }


Agenda



Java EE no Java SEProvido por Spring


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.0


Agenda



JPQLAceita SQL ??


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] [order by]


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ção


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();}


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-Compiladas


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 05. q.setMaxResults(10); // only fetch 106. List results = q.getResultList();


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();


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

r


Bibliografia

●EJB 3.0 In Action ○ [ISBN : 1-933988-34-7]

● JPA 101: Java Persistence Explained○ [ISBN : 0-9765534-1-4]

java persintence api

Documents