JPA - CRIStAL
publicité
Cedric Dumoulin
Aperçu
Rappels
Contexte de Persistance et état des entités
Associations
Héritage
Classes embarquées
Langage de requêtes
JPA et Container JEE
Cours
Le cours de Laurent Guerin
Page du site
http://www.laurent-guerin.fr/jpa
Lien direct Cours-JPA-v1.2.pdf
http://www.laurent-guerin.fr/jpa/Cours-JPAv1.2.pdf?attredirects=0&d=1
Licences
Creative Commons (CC) : BY-NC-SA"
( cf http://creativecommons.org/licenses/ )
<?xml version="1.0" encoding="UTF-8"?>
<persistence version="2.1" ...
<persistence-unit name="people" transaction-type="RESOURCE_LOCAL">
<class>de.vogella.jpa.eclipselink.model.Person</class>
Rappels
<properties>
<property name="javax.persistence.jdbc.driver"
value="org.apache.derby.jdbc.EmbeddedDriver" />
<property name="javax.persistence.jdbc.url"
value="jdbc:derby:F:\temp\derby\db1;create=true" />
<!-- EclipseLink should create the database schema automatically -->
<property name="eclipselink.ddl-generation" value="drop-and-create-tables" />
<property name="eclipselink.ddl-generation.output-mode"
value="database" />
</properties>
@Entity
public class Person {
@Id
</persistence-unit>
@GeneratedValue(strategy = GenerationType.TABLE)
</persistence>
private String id;
private String firstName;
private String lastName;
// ...
}
factory = Persistence
.createEntityManagerFactory(PERSISTENCE_UNIT_NAME);
EntityManager em = factory.createEntityManager();
// ...
em.getTransaction().begin();
Person person = new Person();
person.setFirstName("Jim_" + i);
person.setLastName("Knopf_" + i);
em.persist(person);
em.getTransaction().commit();
// ...
}
DB
Copyright Laurent Guerin (Java Parsistence API v1.1)
Etats d’une entité
http://java.boot.by/scbcd5-guide/ch06.html
Copyright
Copyright Laurent Guerin (Java Parsistence API v1.1)
Cours-JPA-v1.1.pdf Slides 30 a 38
Les types de liens JPA
1 lien UML bidirectionel 2 demi liens Java uni-directionel
ManyToOne
OneToOne
OneToOne
OneToMany
ManyToMany
Lien (inverse side)
Lien (owning side)
ManyToMany
Les types de liens JPA
Une relation entre 2 entités 2 liens en Java
Chaque lien à un sens ET une cardinalité :
OneToOne
OneToMany
ManyToOne
ManyToMany
OwningSide
Le coté « propriétaire » du lien
Celui qui possède la Foreign Key
Inverse Side
Le coté référencé par le propriétaire
Exemple – Many To One
(Owning Side)
@Entity
public class Employee {
@Id
private int id;
@ManyToOne
private Department department;
// ...
}
ONE:
simple référence
sur une entité
One To Many (Inverse Side)
@Entity
public class Department {
@Id
private int id;
@OneToMany(mappedBy="department")
private Collection<Employee> employees;
// ...
}
Attribut qui pointe
sur cette entité
dans l’owningSide
Coté MANY :
Collection
Many To Many
Introduction d’une table intermédiaire
@Entity
public class Employee {
@Id
private int id;
// ...
@ManyToMany
private Collection<Project> projects;
// ...
Many To Many
Spécification de la table intermédiaire
@Entity
public class Employee {
OwningSide
@Id
(choix arbitraire)
private int id;
// ...
@ManyToMany
@JoinTable( name ="EMP_PROJ",
InverseSide
joinColumns=@JoinColumn(name="EMPLOYEE_ID"),
inverseJoinColumns=@JoinColumn(name="PROJECT_ID") )
private Collection<Project> projects;
// ...
Chargement glouton/fainéant
Lorsqu’une entité est chargé dans le
« persistenceContext » par l’EntityManager,
ses liens peuvent être:
Immédiatement chargés : « eager loading »
Chargés plus tard, quand l’application va les utiliser
« lazy loading »
@Entity
public class Employee {
@Id
private int id;
@OneToOne(fetch=FetchType.LAZY)
private ParkingSpace parkingSpace;
// ...
}
Entités et héritage
Les entités supportent
L’héritage de classe
Les associations polymorphiques
(qui pointe sur un type parent d’une hiérarchie)
Les requêtes polymorphiques
(qui retournent différent types d’une hiérarchie)
(qui retourne un sous-type d’une hiérarchie)
Une entités peut étendre une classe non entité
Une classe non entité peut étendre une classe entité
Une entité peut être abstraite
Entités abstraites
Une classe entity peut être marqué « abstract »
Une entité abstraite est comme une entité concrète
Mais elle ne peut pas être instancié !
Elle peut être employé dans une requête
La requête retourne des types concrets
Exemple entité abstraite
@Entity
public abstract class Employee {
@Id
protected Integer employeeId;
...
}
@Entity
public class FullTimeEmployee extends Employee {
protected Integer salary;
...
}
@Entity
public class PartTimeEmployee extends Employee {
protected Float hourlyWage;
}
Mapped superclasses
Permet d’hériter d’une classe
Dont des états doivent être persistant
Mais qui ne doit pas être une entité
Décorer avec
javax.persistence.MappedSuperclass:
Ce type de classe ne peut pas
Etre dans une requête
Être demandé a l’EntityManager ou dans une Query
Il faut utiliser l’entity enfant
Etre la cible d’une association d’une autre entité
Il n’y a pas de table correspondant dans la DB
Exemple Mapped Superclasses
@MappedSuperclass
public class Employee {
@Id
protected Integer employeeId;
...
}
@Entity
public class FullTimeEmployee extends Employee {
protected Integer salary;
...
}
@Entity
public class PartTimeEmployee Employee {
protected Float hourlyWage; extends
...
}
Superclasses non-entités
Une entité peut hériter d’une classe non entité
La supeclass peut être concrète ou abstraite
L’état de la superclass est alors non persistant
La superclasse ne peut pas
Etre utilisé dans l’EntityManager, une requête
Stratégies d’héritage
Une table par hiérarchie
Une table par entité concrète de la hiérarchie
La table contient les propriété de la classe, et des classes
parent
Une table par classe de la hiérarchie
La table contient uniquement les propriétés de la classe
Il faut faire un « JOIN » pour obtenir toutes les
propriétés
Definir la strategie d’heritage
Utiliser @Inheritance
import
javax.persistence.InheritanceType;
public enum InheritanceType {
SINGLE_TABLE,
JOINED,
TABLE_PER_CLASS
};
Strategie par défaut
InheritanceType.SINGLE_TABLE;
Single Table
InheritanceType.SINGLE_TABLE
Toutes les instances d’une hiérarchie sont dans
une seule et même table
La table contient une colonne supplémentaire
discriminant
Peut être définit par une annotation
Single Table
Avantages
Bon support pour les associations et les requêtes
polymorphiques
Inconvénients
Les colonnes doivent être nullable
Peut contenir beaucoup de valeurs null.
Une table par classe concrete
InheritanceType.SINGLE_TABLE
Chaque classe concrète a sa propre table
Chaque table contient toutes les propriétés (y compris
des superclasses)
Une table par classe concrete
Avantages
Diminue les valeurs nulles
Inconvénients
Mauvais support du polymorphisme
Des join sur les tables sont requis
Cette stratégie est optionnel
Elle n’est pas supporté par toutes les implémentation de JPA
Strategie « JOINED »
InheritanceType.JOINED,
La classe racine de la hiérarchie a sa propre table
Chaque sous-classe a sa table
Une table ne contient que les propriétés de la classe
Strategie « JOINED »
Avantages
Bon support pour les associations et les requêtes
polymorphiques
Pas de valeurs nulles superflues
Inconvénients
Des join sont requis pour obtenir un objet
Peut entrainer des mauvaises performances
Les classes peuvent nécessiter une colonne discriminant
Dépend de l’implémentation
Pas un problème si on laisse la création de table auto
Bibliographie
Entity Inheritance
Chap 37.2 - Java EE 7 Tutorial
http://docs.oracle.com/javaee/7/tutorial/doc/
Classes embarquées
Pourquoi faire ?
Used to represent the state of an entity but don't have
a persistent identity of their own
Instances of an embeddable class share the identity of
the entity that owns it
Permet de concevoir en pensant “orienté objet”
L’objet n’est pas persistant en lui-même
Il est persisté avec l’entité qui le détient
Exemple
@Embeddable
public class ZipCode {
String zip;
String plusFour;
...
}
Classe embarqué
Même règles que les entity
Mais annotation @Embeddable
@Embedded est optionnel
@Entity
public class Address {
@Id
protected long id
String street1;
String street2;
String city;
String province;
@Embedded
ZipCode zipCode;
String country;
...
}
Régles
Classe embarqué
Même règles que les entity
Mais annotation @Embeddable
Peut avoir des classes embarqués, des associations, …
Bibliographie
Embeddable Classes in Entities
Chap 37.1.6 - Java EE 7 Tutorial
http://docs.oracle.com/javaee/7/tutorial/doc/
Présentation
Cours Laurent Guerin Cours-JPA-v1.2.pdf
Slides s82p41 -> ss89p45
Bibliographie
The Java Persistence Query Language
Chap 39 - Java EE 7 Tutorial
http://docs.oracle.com/javaee/7/tutorial/doc/
Cour Laurent Guerin
http://www.laurent-guerin.fr/jpa/Cours-JPA-
v1.1.pdf?attredirects=0&d=1
A faire !!!
Tuto JEE 7 Managing Entities
Bibliographie
Managing Entities
Chap 37.3 - Java EE 7 Tutorial
http://docs.oracle.com/javaee/7/tutorial/doc/
Cour Laurent Guerin
http://www.laurent-guerin.fr/jpa/Cours-JPA-
v1.1.pdf?attredirects=0&d=1
Bibliographie
The Java EE 7 Tutorial
http://docs.oracle.com/javaee/7/tutorial/doc/
Java - JPA
http://www.laurent-guerin.fr/jpa
45. JPA (Java Persistence API)
JM Doudoux
http://jmdoudoux.developpez.com/cours/developpons/java/chapjpa.php
La persistance des données avec JPA
http://fr.openclassrooms.com/informatique/cours/creez-votreapplication-web-avec-java-ee/la-persistance-des-donnees-avec-jpa
Mapping Objects to Relational Databases: O/R Mapping In Detail
http://www.agiledata.org/essays/mappingObjects.html
The Object-Relational Impedance Mismatch
http://www.agiledata.org/essays/impedanceMismatch.html
Cour Laurent Guerin
http://www.laurent-guerin.fr/jpa/Cours-JPA-
v1.1.pdf?attredirects=0&d=1
