Java PersistenceN2TR

Chapitre12 : La persistance dans JAVA

Riadh Bouhouchi

1 1

MASTER PROFESSIONNEL NOUVELLES TECHNOLOGIES DES TELECOMMUNICATIONS ET RESEAUX

(N2TR)

Cours J2EE UVT La persistance dans JAVA

Objectif : Ce chapitre vous permettra de comprendre les principes de persistance dans java, tel que le mapping dobjet relationnel, les requtes dentits, les Callbacks et les Listeners, quon va appliquer dans quelques exemples.


Riadh Bouhouchi

2 2

Sommaire

Vue densemble sur les spcifications du JPA ........................................................................................... 3

Comprendre les entits ............................................................................................................................ 3

Le mapping objet-relationnel ................................................................................................................... 3

Entits dinterrogation ............................................................................................................................. 4

Rappels et Auditeurs (Callbacks and Listeners) ......................................................................................... 7

Assembler le tout ensemble : ................................................................................................................... 8

La rdaction de lentit Book : ................................................................................................................. 8

Rdaction de la classe principale Main : .............................................................................................. 9

Unit de la persistance pour la classe principale Main : .................................................................... 10

La compilation avec Maven : .................................................................................................................. 11

L'excution de la classe principale avec Derby : ...................................................................................... 14

La rdaction de la classe BookTest : ....................................................................................................... 16

Unit de persistance pour la classe BookTest : ....................................................................................... 18


Riadh Bouhouchi

3 3

Vue densemble sur les spcifications du JPA JPA 1.0 a t cr avec Java EE 5 afin de rsoudre le problme de la persistance des donnes. Elle propose des modles orients objet et relationnelles ensemble. JPA est une abstraction du JDBC qui permet d'tre indpendant de SQL. Toutes les catgories et les annotations de cette API sont dans le package javax.persistence. Les principales composantes de cette API sont comme suit:

ORM, qui est le mcanisme de mapping d'objets des donnes stockes dans une base de donnes relationnelle.

Un gestionnaire d'entits API pour effectuer des oprations sur les bases de donnes, telles que la cration, la lecture, la mise jour, la suppression (CRUD) des donnes. Cette API vous permet d'viter d'utiliser l'API JDBC directement.

La Java Persistence Query Language (JPQL), qui vous permet de rcuprer les donnes avec un langage de requte orient objet.

Les transactions et les mcanismes de verrouillage de l'accs aux donnes en mme temps fourni par lAPI Java Transaction (JTA).

Comprendre les entits Lorsquon parle du mapping des objets d'une base de donnes relationnelle, la persistance des objets, ou l'interrogation des objets, le terme entit devrait tre utilis plutt que le terme objets. Les objets sont des instances qui viennent de vivre dans la mmoire. Les entits sont des objets qui vivent peu de temps dans la mmoire et de faon persistante dans une base de donnes. Ils ont la capacit d'tre relis une base de donnes, et peuvent tre concrets ou abstraits. Ils prennent en charges l'hritage, les relations, et ainsi de suite. Ces entits, une fois mappes, peut tre gr par le JPA. Vous pouvez persister, une entit dans la base de donnes, la supprimer et l'interroger en utilisant un langage de requte (Java Persistence Query Language, ou JQPL).

Le mapping objet-relationnel Le principe de l'ORM est de dlguer des outils externes ou des frameworks (le JPA dans notre cas) la tche de crer une correspondance entre les objets et les tableaux. Le monde des classes, des objets et attributs peuvent tre mapps des bases de donnes relationnelles en tableaux contenant des lignes et des colonnes. Le mapping donne une vue oriente objet pour les dveloppeurs qui peut de manire transparente l'utilisation des entits au lieu des tables. Mais comment le JPA mappe les objets une base de donnes? Cest avec des mtadonnes, chaque mtadonne est associe une entit qui dcrit le mapping. Ces mtadonnes permettent au fournisseur de persistance de reconnatre une entit et d'interprter le mapping.


Riadh Bouhouchi

4 4

Cette mtadonne peut tre rdige en deux formats diffrents: Annotations: Le code de l'entit est directement annot avec toutes sortes d'annotations

qui sont dcrits dans le dossier javax.persistence. Les descripteurs XML: au lieu de (ou en plus) les annotations, vous pouvez utiliser les

descripteurs XML. Le mapping est dfinie dans un fichier XML externe qui sera dploy avec lentit. Cela peut tre trs utile lors de changements de configuration de base de donnes en fonction de l'environnement, par exemple.

Pour rendre plus facile le mapping, le JPA (comme beaucoup d'autres spcifications Java EE 6) utilise le concept de configuration par exception (parfois appel programmation par exception). L'ide est que le JPA a certaines rgles de mappage par dfaut (par exemple, le nom du tableau est le mme que le Nom de l'entit). Si vous tes satisfait, vous n'avez pas besoin d'utiliser des mtadonnes supplmentaires (aucune annotation ou XML est ncessaire), mais si vous ne voulez pas que le fournisseur applique les rgles par dfaut, vous pouvez personnaliser le mapping vos propres besoins en utilisant des mtadonnes. En d'autres termes, d'avoir fournir une configuration est l'exception la rgle.

Donc, nous allons voir comment cela s'applique une entit :

Book

Id :Long

Title :String

Price :float

Description :String

nbOfPage:integer

illustrations:

Boolean

figure 2-1 montre une entit book avec quelques attributs.

Comme vous pouvez le voir, certains d'entre eux sont annots (id, titre et description), et certains ne le sont pas.

Entits dinterrogation Le JPA permet de mapper les entits aux bases de donnes et aussi de les interroger l'aide de diffrents critres. La puissance du JPA cest qu'il offre la possibilit dinterroger des entits de leurs relations dans un chemin oriente objet sans avoir utiliser les cls trangres de la base de donnes ou des colonnes.

Book

ID begint Nullable=false

Title

Price

Description

Isbn

NBOFPAGE

ILLUSTRARATION

Varchar(255) Double Varchar(2000) Varchar(250) Integer Smallint

Nullable=false

Nullable=true Nullable=true Nullable=true Nullable=true Nullable=true

mapping


Riadh Bouhouchi

5 5

La partie responsable de l'API pour orchestrer les entits est le gestionnaire d'entits. Son rle est la gestion des entits, lire et crire dans une base de donnes, et de permettre des oprations simples (CRUD) sur les entits ainsi que des requtes complexes en utilisant JPQL. Dans un sens technique, le gestionnaire d'entits est juste une interface dont l'application est faite par le fournisseur de persistance, EclipseLink.

Ce bout de code montre comment crer un gestionnaire d'entits et de persister une entit Book:

Main

Figure 2-2. Le gestionnaire d'entits en interaction avec l'entit et la base de donnes sous-jacentes.

Dans la figure 2-2, vous pouvez voir comment l'interface EntityManager peut tre utilise par une classe pour manipuler les entits (dans ce cas, Book). Avec des mthodes telles que persist () et find (), les gestionnaires d'entits cachent le JDBC de la base de donnes et l'instruction INSERT ou SELECT du langage SQL.

EntityManager

Persist(entity :Object) :void

Find(entityClass, :Class,primaryKey :Object) :

Book

Id :Long

Title :String

Price :float

Description :String

nbOfPage:integer

illustrations:

Boolean

EntityManagerFactory emf = Persistence.createEntityManagerFactory("chapter02PU"); EntityManager em = emf.createEntityManager(); em.persist(book);

SQL/JDBC

DataBase


Riadh Bouhouchi

6 6

Le gestionnaire d'entits vous permet galement dinterroger (effectuer des requtes) les entits. Une requte dans ce cas est similaire une interrogation de la base de donnes, sauf qu'au lieu d'utiliser SQL, les requtes JPA appliqus aux entits utilisent le JPQL. Sa syntaxe utilise l'objet dannotation familire point (.). Pour rcuprer tous les books qui ont le titre de H2G2, vous pouvez crire le code suivant:

Une dclaration JPQL peut tre excut avec des requtes dynamiques (cr dynamiquement l'excution), des requtes statiques (dfinies statiquement lors de la compilation), ou mme avec une dclaration SQL natif. La requte statique, galement connu sous le nom des requtes nommes, sont dfinies en utilisant soit des annotations soit, des mtadonnes XML. La dclaration prcdente JPQL peut, par exemple, tre dfinie comme une requte nomme sur l'entit book. La figure 2-2 montre une entit Book dfinir la requte findBookByTitle nomm en utilisant lannotation

@NamedQuery. La requte findBookByTitle Named

SELECT b FROM Book b WHERE b.title = 'H2G2'

@Entity @NamedQuery(name = "findBookByTitle", query = "SELECT b FROM Book b WHERE b.title ='H2G2'")

public class Book { @Id @GeneratedValue private Long id; @Column(nullable = false) private String title; private Float price; @Column(length = 2000) private String description; private String isbn; private Integer nbOfPage; private Boolean illustrations; // Constructors, getters, setters }


Riadh Bouhouchi

7 7

Rappels et Auditeurs (Callbacks and Listeners)

Les entits sont simples des Plain (pleine) Old (ancienne) Java Object (POJO) qui sont, ou qui ne sont pas gres, par le gestionnaire d'entits. Ils sont grs, quand tils ont une identit persistance, et leur tat est synchronis avec la base de donnes, et quand ils ne le sont pas (c'est dire qu'ils sont dtachs du gestionnaire d'entits), ils peuvent tre utilises comme n'importe quelle autre classe Java. Cela signifie que les entits ont un cycle de vie, comme montre la figure 2-3.

Figure 2-3. Le cycle de vie d'une entit

Lorsque vous crez une instance de l'entit book avec le nouvel oprateur, lobjet existe dans la mmoire, et le JPA ne sait rien ce sujet. Quand il devient gr par le gestionnaire d'entits, son tat est mapp et synchronis la table des books. L'appel de la mthode EntityManager.remove () supprime les donnes de la base de donnes, mais l'objet Java continue vivre dans la mmoire jusqu' ce qu'il soit rcuprer par le ramasse-miettes. Les oprations effectues des entits se rpartissent en quatre catgories: la persistance, la mise jour, la suppression, et le chargement, qui correspondent respectivement l'insertion, la mise jour, la suppression et la slection dans la base de donnes. Chaque opration a un pr "et" Post "vnement (sauf pour le chargement, ce qui a seulement un "Post" vnement) qui peut tre intercepte par le gestionnaire d'entits invoquer une mthode mtier. Vous pouvez penser des mthodes de rappel et les auditeurs comme analogue dclenche dans une base de donnes relationnelle.

Exists in memory

Detached Managed Removed

DataBase


Riadh Bouhouchi

8 8

Assembler le tout ensemble :

Maintenant que vous savez un peu plus sur le JPA, EclipseLink, les entits, le gestionnaire d'entits, et le JPQL, mettons tout ensemble et crivons une petite application qui persiste une entit dans une base de donnes.

L'ide est d'crire un book avec une entit simple et une classe principale qui persiste un book.

Vous pourrez ensuite ltablir avec Maven 2 et l'excuter avec EclipseLink et une base de

donnes client Derby.

Pour montrer avec que cest facile dunir un test a une entit, je vais vous montrer comment crire une classe de test (BookTest) avec JUnit 4 testnet utiliser le mode intgr de Derby pour la persistance des donnes en utilisant une base de donnes. Cet exemple suit la structure de rpertoire Maven, alors les classes et les fichiers doivent tre placs dans les rpertoires suivants:

src / main / java: Pour l'entit du book et de la classe principale

src / main / resources: Pour le persistence.xml fichier utilis par la classe principale

src / test / java: Pour la classe BookTest, qui est utilis pour les tests unitaires

src / test / resources: Pour le persistence.xml fichier utilis par les cas de test

pom.xml: Pour le modle Maven Project Object (POM), qui dcrit le projet et ses dpendances sur d'autres modules externes et des composants

La rdaction de lentit Book :

L'entit book, illustr dans la figure 2-3, doit tre dvelopp sous le rpertoire src / java main /. Elle a plusieurs attributs (titre, prix, etc.), diffrents types de donnes (String, Char, Entier, et Boolean) et quelques annotations JPA:

@ Entity informe le fournisseur de persistance que cette classe est une entit et qu'il devrait le grer.

@ Id dfinit l'attribut id comme tant la cl primaire.

L'annotation @ GeneratedValue informe le fournisseur de persistance pour gnrer automatiquement la cl primaire en utilisant la base de donnes sous-jacentes d'utilit id.

L'annotation @ Column est utilise pour spcifier que le titre de proprit doit tre non nulle, quand persist et de changer la longueur maximale par dfaut de la colonne description.


Riadh Bouhouchi

9 9

L'annotation @ NamedQuery dfinit une requte nomme qui utilise JPQL pour rcuprer toutes les books de la base de donnes.

Rdaction de la classe principale Main :

La classe principale, dans la figure 2-4, est sous le mme rpertoire que l'entit book. Elle commence en crant une nouvelle instance de l'entit book (en utilisant le nouveau mot-cl Java) et dfinit certaines valeurs ses attributs. Il n'y a rien de spcial ici, juste du pur code Java. Il utilise ensuite la classe de persistance pour obtenir une instance d'un EntityManagerFactory qui fait rfrence une persistance unit appele chapter02PU, quon va dcrire plus loin dans la section Persistance Unit pour la classe principale Cette EntityManagerFactory cre une instance d'un EntityManager . Tel que mentionn prcdemment, le gestionnaire d'entits est la pice centrale du JPA capable de crer une transaction, qui persistent lobjet book l'aide de la mthode EntityManager.persist (), puis de valider la transaction. la fin de la mthode main (), l'EntityManager et EntityManagerFactory sont ferm en mme temps la fois pour librer les ressources du fournisseur.

package com.apress.javaee6.chapter02; @Entity @NamedQuery(name = "findAllBooks", query = "SELECT b FROM Book b") public class Book { @Id @GeneratedValue private Long id; @Column(nullable = false) private String title; private Float price; @Column(length = 2000) private String description; private String isbn; private Integer nbOfPage; private Boolean illustrations; // Constructors, getters, setters }


Riadh Bouhouchi

10 10

Unit de la persistance pour la classe principale Main : Comme vous pouvez le voir dans la classe principale, le EntityManagerFactory a besoin d'une unit

appele persistance chapter02PU. Cette unit de persistance doit tre dfini dans le fichier

persistence.xml dans le rpertoire src / main / resources / rpertoire META-INF (voir Exemple 2-5). Ce

fichier, requis par la spcification JPA, est important car il relie le fournisseur du JPA (EclipseLink dans

notre cas) la base de donnes (Derby).Il contient toutes les informations ncessaires pour se connecter

la base de donnes (target, URL, pilote JDBC, utilisateur et mot de passe) et en informe le fournisseur

de la base de donnes en mode gnration (un moyen de crer des tables s'ils n'existent pas).

package com.apress.javaee6.chapter02; public class Main { public static void main(String[] args) { // Creates an instance of book Book book = new Book(); book.setTitle("The Hitchhiker's Guide to the Galaxy"); book.setPrice(12.5F); Chapter 50 2 JAVA PER SISTE NCE book.setDescription("Science fiction comedy book"); book.setIsbn("1-84023-742-2"); book.setNbOfPage(354); book.setIllustrations(false); // Gets an entity manager and a transaction EntityManagerFactory emf = Persistence.createEntityManagerFactory("chapter02PU"); EntityManager em = emf.createEntityManager(); // Persists the book to the database EntityTransaction tx = em.getTransaction(); tx.begin(); em.persist(book); tx.commit(); em.close(); emf.close(); } }


Riadh Bouhouchi

11 11

L'lment dfinit le fournisseur de persistance, dans notre cas, EclipseLink.

Cette unit de persistance liste toutes les entits qui doivent tre grs par le gestionnaire d'entits .Ici, le tag se rfre l'entit book.

La compilation avec Maven :

Vous avez tous les ingrdients pour excuter l'application: l'entit book que vous avez besoin de persister, la classe principale, qui utilise un gestionnaire d'entits, et l'unit de persistance contraignant l'entit la base de donnes Derby. Pour compiler ce code, au lieu d'utiliser la commande du compilateur javac directement, vous allez utiliser Maven.

org.eclipse.persistence.jpa.PersistenceProvider com.apress.javaee6.chapter02.Book


Riadh Bouhouchi

12 12

Vous devez d'abord crer un fichier pom.xml qui dcrit le projet et ses dpendances telles que l'API JPA. Vous devez galement informer Maven que vous utilisez Java SE 6 en configurant le maven-compiler-plugin.

4.0.0 com.apress.javaee6 chapter02 1.0 chapter02 org.eclipse.persistence javax.persistence 1.1.0 org.eclipse.persistence eclipselink 1.1.0 org.apache.derby Chapter 52 2 JAVA PER SISTE NCE derbyclient


Riadh Bouhouchi

13 13

10.4.2.0 org.apache.derby derby 10.4.2.0 test junit junit 4.5 test org.apache.maven.plugins maven-compiler-plugin true 1.6 1.6


Riadh Bouhouchi

14 14

Tout d'abord, pour pouvoir compiler le code, vous avez besoin de l'API JPA qui dfinit l'ensemble des annotations et des classes qui sont dans le package javax.persistence. Vous obtiendrez ces classes dans le JAR dans javax.persistence artefact ID et stockes dans le rfrentiel Maven. Le runtime EclipseLink (le fournisseur de persistance) est dfini dans l'artefact eclipselink ID. Vous avez besoin ensuite des pilotes JDBC pour se connecter Derby. L'artefact derbyclient ID se rfre la JAR qui contient le pilote JDBC pour se connecter Derby en mode serveur et l'artefact derby ID contient les classes pour utiliser une base de donnes embarque Derby. Notez que cet artefact ID est porte pour les essais ( test champ d'application) et a une dpendance sur JUnit 4. Pour compiler les classes, il faut ouvrir un interprteur de commande en ligne dans le rpertoire racine qui contient le fichier pom.xml et entrer la commande Maven suivante: mvn compile. Vous devriez voir le message BUILD SUCCESSFUL vous informer que la compilation a t couronne de succs. Maven cre un sous-rpertoire cible avec tous les fichiers de classe ainsi que les fichiers de persistance.

L'excution de la classe principale avec Derby : Avant d'excuter la classe principale, vous devez lancer Derby. La meilleure faon de faire est d'aller dans le rpertoire% DERBY_HOME \ bin% et excuter le script startNetworkServer.bat. Derby dmarre et affiche les messages suivants dans la console:

Le processus de Derby est l'coute sur le port 1527 et attend le pilote JDBC pour envoyer des

instructions SQL. Pour excuter la classe principale, vous pouvez utiliser la commande de linterprteur

Java ou utiliser Maven comme suit:

Lorsque vous excutez la classe principale, plusieurs choses se produisent. Tout d'abord, Derby

cre automatiquement la base de donnes chapter02DB et l'entit book est initialise. C'est parce que

dans le fichier persistence.xml vous avez ajout la proprit create = true l'URL JDBC:

Security manager installed using the Basic server security policy. Apache Derby Network Server - 10.4.2.0 - (689064) started and ready to accept connections on port 1527

mvn exec:java -Dexec.mainClass="com.apress.javaee6.chapter02.Main"


Riadh Bouhouchi

16 16

Pour en revenir au code de l'entit de books, parce que vous avez utilis le GeneratedValue annotation (pour gnrer automatiquement lID), EclipseLink a cr une table pour stocker des squences de numrotation (le tableau de squence). Pour la structure de la table BOOK, le JPA a suivi certaines conventions par dfaut comme le nom de la table et les colonnes aprs le nom de l'entit et les attributs. L'annotation @ Column a annul certaines de ces valeurs par dfaut tels que la longueur de la colonne de description, qui est fix 2000.

La rdaction de la classe BookTest : C'est ainsi que vous allez excuter notre classe BookTest, en utilisant le mode incorpor de Derby. Maven utilise deux rpertoires diffrents, l'un pour stocker le code de l'application principale et lautre pour les classes de tests. La classe BookTest, passe sous le rpertoire src / test / java et test qui le gestionnaire d'entits peuvent persister un book et le rcuprer de la base de donnes.


Riadh Bouhouchi

17 17

public class BookTest { private static EntityManagerFactory emf; private static EntityManager em; private static EntityTransaction tx; @BeforeClass

public static void initEntityManager() throws Exception { emf = Persistence.createEntityManagerFactory("chapter02PU"); em = emf.createEntityManager(); } @AfterClass public static void closeEntityManager() throws SQLException { em.close(); emf.close(); } @Before public void initTransaction() { tx = em.getTransaction(); } @Test public void createBook() throws Exception { // Creates an instance of book Book book = new Book(); book.setTitle("The Hitchhiker's Guide to the Galaxy"); book.setPrice(12.5F); book.setDescription("Science fiction comedy book"); book.setIsbn("1-84023-742-2"); book.setNbOfPage(354); book.setIllustrations(false); // Persists the book to the database tx.begin(); em.persist(book); tx.commit(); assertNotNull("ID should not be null", book.getId()); // Retrieves all the books from the database List books = em.createNamedQuery("findAllBooks").getResultList(); assertNotNull(books); } }


Riadh Bouhouchi

18 18

Comme la classe principale, BookTest a besoin de crer une instance EntityManager l'aide d'un

EntityManagerFactory.

Pour initialiser ces composants, vous pouvez utiliser le JUnit 4 fixtures.

Le @BeforeClass Et @AfterClass annotations permettent lexcution de certains de codes une seule fois,

avant et aprs que la classe soit excute. C'est l'endroit idal pour crer et fermer un EntityManager

par exemple. L'annotation @ Avant vous permet d'excuter du code avant chaque test, qui obtient une

transaction.

Le createBook () est le scnario de test, il est annot avec l'annotation JUnit @ Test.

Cette mthode persiste un book (en utilisant la mthode EntityManager.persist ()) et contrle si l'id a t

gnr automatiquement par EclipseLink (avec assertNotNull). Si c'est le cas, la requte nomme

findAllBooks est excute et elle vrifie si la liste retourne est nulle.

Unit de persistance pour la classe BookTest : Maintenant que la classe de test est crite, vous avez besoin d'un autre fichier persistence.xml utiliser avec Derby embarqus. Le fichier prcdent persistence.xml dfinit le pilote JDBC et une connexion Web pour le serveur Derby, qui doit tre lanc dans un processus spar. Le src / test / resources / META-INF /

org.eclipse.persistence.jpa.PersistenceProvider com.apress.javaee6.chapter02.Book


Riadh Bouhouchi

19 19

Il ya d'autres changements entre les fichiers persistence.xml. Par exemple, la gnration DDL est

la suppression et la cration des tables au lieu de crer des tables, pour tester des tables supprimer et

recrer si vous avez une nouvelle structure de base de donnes. Notez galement que le

niveau d'enregistrement est FINE au lieu de INFO . Encore une fois, c'est bon pour les essais,

comme vous pouvez obtenir de plus amples renseignements au cas o quelque chose tournerait mal.

L'excution de la classe BookTest avec Embedded Derby. Rien n'est plus facile que l'excution du test:

vous pouvez compter sur Maven.

Ouvrez une console dans le rpertoire o se trouve le fichier pom.xml et entrez la commande suivante:

Maven nous informe du rsultat :

mvn test

Tests run: 1, Failures: 0, Errors: 0, Skipped: 0 [INFO] ---------------------------------------------------------------- [INFO] BUILD SUCCESSFUL [INFO] ---------------------------------------------------------------- [INFO] Total time: 19 seconds [INFO] Finished [INFO] Final Memory: 4M/14M [INFO] ----------------------------------------------------------------

Java PersistenceN2TR

Documents

Transcript of Java PersistenceN2TR