Java Persistence API - e
publicité
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
