Transcript

1. Introduction ´ JPA (Java Persistence API )
2. www.facebook.com/pages/FreelancerTech/822357474482862 www.twitter.com/FREELANCERTECH (@FREELANCERTECH) Une équipe d´experts dans leur domaine technologique qui ont décidé de se mettre ensemble pour offrir leurs services en fonction de leurs disponibilités, www.freelancertech.net
3. • Historique • ORM : Object Relational Mapping • JPA : Java Persistence Api • Entity: Entités • Autres annotations • Contexte de persistance • Opérations prises en charge par le gestionnaire d´entités • Cycle de vie d´une instance d´entité • Obtention d´une fabrique EntityManagerFactory • Création du gestionnaire d´entité EntityManager • Exemple d´insertion d´un livre • Relations entre entités • Référence • Questions Plan www.freelancertech.net
4. Base de donnée MySQL Couche DAO Couche Métier Couche UI JDBC Historique : Accès directement ´ la base de donnée grâce ´ l´API standard JDBC de Java
5. • Pour des raisons de performances, le coût d'ouverture / fermeture d'une connexion n'est pas négligeable, o Connection con = DriverManager.getConnection(url, "login", "password"); o //les ordres SQL o con.close(); • L´utilisation du langage SQL rend la couche DAO difficilement maintenable, o String insertStatement = "Insert into Client(Nom, Prenom,Nature) values (?, ?, ?)" Problématiques de l´accès direct ´ la BD ´ l´aide de jdbc : www.freelancertech.net
6. Pour pallier ´ cette problématique et faciliter l´écriture de la couche DAO, La communauté Java a donc fait naître des Frameworks ORM , tels que Hibernate, Toplink, EclipseLink www.freelancertech.net
7. ORM : Object Relational Mapping Base de donnée MySQL ORM • Hibernate • Toplink • EclipseLink Couche DAO JDBC Pool de Connexions Objet image de la BD www.freelancertech.net [1]
8. ReFactoring de la fonction enregistrée de notre couche DAO www.freelancertech.net
9. Devant le succès des Frameworks ORM, Sun a décidé de standardiser une couche ORM via une spécification appelée JPA apparue en même temps que Java 5 www.freelancertech.net
10. JPA : Java Persistence Api Base de donnée MySQL Implémentation • Hibernate • Toplink • EclipseLink Couche DAO JDBC Pool de Connexions [interface] JPA La spécification JPA est un ensemble d´interface du package javax.persistence [ EntityManager ] void persist(Entity entité) Exemple : javax.persistence.Entity; javax.persistence.EntityManagerFactory; javax.persistence.EntityManager; javax.persistence.EntityTransaction; www.freelancertech.net
11. Refactoring de la fonction enregistrée de notre couche DAO www.freelancertech.net
12. • JPA peut être utilisé par toutes les applications Java, Java SE ou Java EE. • Mapping O/R (objet-relationnel) avec les tables de la BD, facilitée par les Annotations. • Un langage de requête objet standard JPQL pour la récupération des objets, Ses principaux avantages sont les suivants : JPA : Java Persistence Api select p from Personne p order by p.nom asc www.freelancertech.net
13. Entity: Entités @Entity @Table(name = "BOOK") public class Book { @Id @GeneratedValue private Long id; @Column(name = "TITLE",nullable = false) private String title; private Float price; @Basic(fetch = FetchType.LAZY) @Column(length = 2000) private String description; private String isbn; private Integer nbOfPage; private Boolean illustrations //Les Getters et les Setters [1]
14. Autres annotations ? Voir par exemple : JPA Reference http://www.objectdb.com/api/java/jpa ? Les curieux peuvent consulter la spécification java EE 6 ou le tutorial (ou un bon livre) www.freelancertech.net
15. Contexte de persistance Ensemble des instances d´entités gérées a un instant donné, gérées par qui ? Le gestionnaire d´entités : EntityManager Ce contexte peut donc être considéré comme un cache de premier niveau : c´est un espace réduit ou le gestionnaire stocke les entités avant d´écrire son contenu dans la base de données, www.freelancertech.net
16. Opérations prises en charge par le gestionnaire d´entités NB : Un flush() est automatiquement effectué au moins ´ chaque commit de la transaction en cours, www.freelancertech.net [2]
17. Cycle de vie d´une instance d´entité www.freelancertech.net [2]
18. Obtention d´une fabrique EntityManagerFactory L´ interface EntityManagerFactory permet d´obtenir une instance de l´objet EntityManager, EntityManagerFactory emf = Persistence.createEntityManagerFactory("jpa"); « jpa » est le nom de l´unité de persistance, définie dans le fichier de configuration de la couche JPA METAINF/persistence.xml. [3]
19. Création du gestionnaire d´entité EntityManager EntityManagerFactory emf = Persistence.createEntityManagerFactory("jpa"); EntityManager em = emf.createEntityManager() ; www.freelancertech.net
20. Exemple d´insertion d´un livre public class Main { public static void main(String[] args) { // On crée une instance de livre Book book = new Book(); book.setTitle("MUGC: JPAMYSQL"); book.setPrice(12.5F); book.setDescription("Science fiction"); … // On récupère un pointeur sur l´entity manager // Remarque : dans une appli web, pas besoin de faire tout cela ! EntityManagerFactory emf = Persistence.createEntityManagerFactory("jpa"); EntityManager em = emf.createEntityManager(); // On rend l´objet « persistant » dans la base (on l´insère) EntityTransaction tx = em.getTransaction(); tx.begin(); em.persist(book); tx.commit(); em.close(); emf.close(); } Version Java SE Version Java EE @Stateless public class BookBean { @PersistenceContext(unitName = "jpa") private EntityManager em; public void createBook() { Book book = new Book(); book.setTitle("MUGC: JPAMYSQL"); book.setPrice(12.5F); book.setDescription("Science fiction"); book.setIsbn("1-84023-742-2"); book.setNbOfPage(354); book.setIllustrations(false); em.persist(book); // Récupère le livre dans la BD par sa clé primaire book = em.find(Book.class, 1234L); System.out.println(book); } } www.freelancertech.net [1]
21. • La Persistence Unit : organise les meta données qui définissent le mapping entre les entités et la base de donnée dans le fichier de configuration METAINF/persistence.xml • La Persistence Manager Factory récupère ces metas données de la Persistence Unit et les interprètent pour créer des Persistence Manager (EntityManager) • Le Persistence Mangager (EntiyManager) gère les échanges entre le code et la base de donnée, c´est ´ dire le cycle de vie des entités • Enfin, les opérations du EntityManager est englobé dans une Transaction. Fonctionnement de JPA [4]
22. Relations entre entités Relation un-´-un @Entity @Table(name = "jpa03_hb_personne") public class Personne { ... @OneToOne(cascade = CascadeType.ALL, fetch=FetchType.LAZY) /*@OneToOne(cascade = {CascadeType.MERGE, CascadeType.PERSIST, CascadeType.REFRESH, CascadeType.REMOVE}, fetch=FetchType.LAZY) */ @JoinColumn(name = "adresse_id", unique = true, nullable = false) private Adresse adresse; ... } @Entity @Table(name = "jpa03_hb_adresse") public class Adresse{ ... /*n´est pas obligatoire*/ @OneToOne(mappedBy = "adresse", fetch=FetchType.EAGER) private Personne personne; ... }www.freelancertech.net [3]
23. Relations entre entités Relation un-´-plusieurs et plusieurs-´-un @Entity @Table(name="jpa05_hb_article") public class Article{ ... // relation principale Article (many) -> Category (one) implémentée par une clé // étrangère (categorie_id) dans Article // 1 Article a nécessairement 1 Categorie (nullable=false) @ManyToOne(fetch=FetchType.LAZY) @JoinColumn(name = "categorie_id", nullable = false) private Categorie categorie; ... } @Entity @Table(name="jpa05_hb_categorie") public class Categorie{ ... // relation inverse Categorie (one) -> Article (many) de la relation Article (many)– > Categorie (one) @OneToMany(mappedBy = "categorie", cascade = { CascadeType.ALL }) private Set<Article> articles = new HashSet<Article>(); ... } www.freelancertech.net [3]
24. Relations entre entités Relation un-´-plusieurs et plusieurs-´-un @Entity @Table(name="jpa06_hb_categorie") public class Categorie{ ... // relation OneToMany non inverse (absence de mappedby) Categorie (one) -> Article (many) // implémentée par une table de jointure Categorie_Article pour qu'´ partir d'une catégorie // on puisse atteindre plusieurs articles @OneToMany(cascade = CascadeType.ALL, fetch = FetchType.LAZY) private Set<Article> articles = new HashSet<Article>(); ... } www.freelancertech.net [3]
25. Relations entre entités Relation plusieurs-´-plusieurs @Entity @Table(name = "jpa07_hb_activite") public class Activite{ ... // relation inverse Activite -> Personne @ManyToMany(mappedBy = "activites") private Set<Personne> personnes = new HashSet<Personne>(); ... } @Entity @Table(name = "jpa07_hb_personne") public class Personne { ... // relation Personne (many) -> Activite (many) via une table de jointure personne_activite @ManyToMany(cascade={CascadeType.PERSIST}) @JoinTable(name="jpa07_hb_personne_activite", joinColumns = @JoinColumn(name = "PERSONNE_ID"), inverseJoinColumns = @JoinColumn(name = "ACTIVITE_ID")) private Set<Activite> activites = new HashSet<Activite>(); ... } pratiquer www.freelancertech.net [3]
26. Travaux pratiques Génération des entités ´ partie d´une base de donnée MySQL avec NetBean www.freelancertech.net
27. Références • [1] www.docstoc.com/docs/150704719/5--JPA-Michel-2012ppt • [2] www.eyrolles.com/Chapitres/9782212120615/Chap10_Djaafar.pdf • [3] www.tahe.ftp-developpez.com/fichiers-archive/jpa.pdf • [4] www.blog.ippon.fr/2011/10/11/jpa-une-magie-qui-se-merite-retour-aux-sources-de-jpa/ www.freelancertech.net
28. Questions www.freelancertech.net