Java Persistence API - e

Java Persistence API
Patrons de conception
Introduction

JPA offre pour le langage JAVA une interface de
programmation standardisée vers les bases de
données relationnelles



Pour les composants lourds EJB au sein d'un serveur
d'application JAVA EE
Pour les objets POJO dans un environnement JAVA
SE avec ou sans cadriciel (Spring)
Mais JPA ne propose pas de modèle d'utilisation
Catalogue de solutions (1)

Patrons de conception de base

Data Access Object (DAO)

Sauvegarde d'entités détachées

Recherche d'entités

Suppression d'entités

Service de Façade et Data Transfer Object (DTO)
Catalogue de solutions (2)

Patrons de conception avancés

Associations bi-directionnelles

Chargement lazy

UUID (Universal Unique Identifier) comme solution
pour les clés primaires

Accès aux champs et accès aux propriétés

Correspondance des hiérarchies d'héritage

Tests
JPA et DAO

Intérêts





Offre une couche d'abstraction légère au-dessus
de JPA
Unifie en les masquant les méthodes du gérant de
persistance (EntityManager)
Permet de masquer certaines méthodes du gérant
de persistance (remove)
Offre un seul point d'entrée pour la persistance
Permet de centraliser en un seul endroit les
requêtes et les paramètres
Modèle DAO avec JPA
Exemple de DAO générique (1)
Interface générique :
public interface Dao<K, E> {
void persist(E entity);
void remove(E entity);
E findById(K id);
}
K représente le type de la clef et E celui de l'entité persistante
Exemple de DAO générique (2)
Classe abstraite générique :
public abstract class JpaDao<K, E> implements Dao<K, E> {
protected Class<E> entityClass;
@PersistenceContext
protected EntityManager entityManager;
public JpaDao() {
ParameterizedType genericSuperclass =
(ParameterizedType) getClass().getGenericSuperclass();
this.entityClass = (Class<E>) genericSuperclass.getActualTypeArguments()[1];
}
public void persist(E entity) { entityManager.persist(entity); }
public void remove(E entity) { entityManager.remove(entity); }
public E findById(K id) { return entityManager.find(entityClass, id); }
}
Exemple de DAO spécifique
Interface spécifique :
public interface EtudiantDao extends Dao<Integer, Etudiant> {
List<Etudiant> findEtudiantRegistredSince(Date date);
List<Etudiant> findAll();
}
Classe spécifique :
public class JpaEtudiantDao extends JpaDao<Integer, Etudiant> implements EtudiantDao {
public List<Etudiant> findEtudiantRegistredSince(Date date) {
Query q = entityManager.createQuery(
"SELECT e FROM " + entityClass.getName() + " e WHERE date >= :date_since");
q.setParameter("date_since", date);
return (List<Etudiant>) q.getResultList();
}
public List<Etudiant> findAll() { ...
}
Client DAO
EtudiantDao etudiantdao = new JpaEtudiantDao();
Etudiant etudiant = new Etudiant();
etudiant.setNumero(1515);
etudiant.setName(''Marignan'');
...
etudiantdao.persist(etudiant);
....
Avantages du DAO avec JPA


Pas de dépendance direct sur l'API JPA pour
les clients du DAO
Types sécurisés par l'utilisation des generics



Si transformation de type (cast) celle-ci est réalisée
par l'implémentation du DAO pas par le client
Un seul emplacement logique pour regrouper
tout le code JPA spécifique aux entités
Un seul emplacement pour délimiter les
transactions