JPA Simplificando a Persistência de Objetos

[ Java Persintence API ]

Simplificando a Persistência de Objetos

Autor: Eduardo R. Carvalho
email: ercarval@gmail.com
7/10/2008 Java Persistence API

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


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
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
8. @Id
9. private Long id;
12. }

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


@Table

1. @Entity
2. @Table(name="BANK_ACCOUNT")
4. @Id
5. private Long id;
8. }


@Version

1. @Entity
4. @Id
5. private Long id;
6. @Version
7. private Long version;
10. }

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


@Column

1. @Entity
4. @Id
5. private Long id;
6. @Version
8. @Column(name="ACCOUNT_NAME")
11. }

● A Annotation Column permite que você
defina o nome da coluna , tamanho ,
precisão, escala, etc.

@Lob

1. @Entity
3. publicclass BankAccount {
4. @Id
5. private Long id;
6. @Version
8. @Column(name="ACCOUNT_NAME")
11. @Lob
12. private String description;
13. }

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


@Enumerated
1. @Entity
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}

@Temporal

1. @Entity
4. @Id
5. //...
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. @Entity
4. @Id
5. //...
10. @Transient
11. private BigDecimal calculatedValue;
12. }

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


Modificador transient
1. @Entity
3. publicclass BankAccount {
4. @Id
5. //...
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

Chave Primária Simples

1. @Entity
3. @Id
4. private Long id;
5. // ...
6. }


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


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

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.

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


Gerenciamento de Relacionamentos

User 1 1 Address
user address

1. @Entity
3. @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. }


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

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


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

One-to-Many

1. @Entity
2. @Table(name="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

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


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

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

@MappedSuperclass


MappedSuperclass


@MappedSuperclass
1. @MappedSuperclass
2. public abstract class ModelBase {
3. @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 {
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
7/10/2008
Tabela por Classe Concreta.
Java Persistence API

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


JOINED
1. @Entity
2. @Inheritance(strategy=JOINED)
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. }


TABLE_PER_CLASS
1. @Entity
2. @Inheritance(strategy=TABLE_PER_CLASS)
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
NK


Packaging
O Ú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

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
7/10/2008
○ Entendido (extended persistence context)
Java Persistence API

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)


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


@PersistenceUnit
EntityManagerFactory 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
7/10/2008 é aplicávelJava Persistence API containers JEE 5
somente a


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. @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. }


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

Java EE no Java SE
Provido 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

JPQL
Aceita 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
7/10/2008
by] Java Persistence API

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

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 0
5. q.setMaxResults(10); // only fetch 10
6. 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]


JPA Simplificando a Persistência de Objetos

Recomendados

Recomendados

Mais conteúdo relacionado

Destaque

Destaque (20)

Semelhante a JPA Simplificando a Persistência de Objetos

Semelhante a JPA Simplificando a Persistência de Objetos (20)

Mais de Eduardo Carvalho

Mais de Eduardo Carvalho (8)

JPA Simplificando a Persistência de Objetos