TP 12 - Persistence avec JPA

TP 12 - Persistence avec JPA
Pascal GRAFFION
2014/01/12 10:28

GLG203 - TP 12 - Persistence avec JPA
Page 2 - dernière modification par Pascal GRAFFION le 2014/01/12 10:28
Table des matières
TP 12 - Persistence avec JPA .................................................................................................................................................... 3
Hello PetStore ! ....................................................................................................................................................................... 3
Entity manager ...................................................................................................................................................................... 3
Expression des besoins ............................................................................................................................................................... 5
Analyse et conception ................................................................................................................................................................ 5
Vue logique ............................................................................................................................................................................. 5
Vue processus .......................................................................................................................................................................... 5
Vue implémentation ................................................................................................................................................................ 5
Architecture .......................................................................................................................................................................... 5
Vue déploiement ...................................................................................................................................................................... 6
Implémentation ........................................................................................................................................................................... 7
Classes métiers ........................................................................................................................................................................ 7
DAOs ....................................................................................................................................................................................... 7
AbstractDataAccessObject la superclasse de tous nos DAOs ................................................................................................ 8
Injection des DAO dans nos EJB ............................................................................................................................................ 9
Recette utilisateur ..................................................................................................................................................................... 10
Tests des DAO ......................................................................................................................................................................... 11
Recette utilisateur finale ........................................................................................................................................................ 12
Résumé ..................................................................................................................................................................................... 12
Références ................................................................................................................................................................................ 12

GLG203 - TP 12 - Persistence avec JPA
Page 3 - dernière modification par Pascal GRAFFION le 2014/01/12 10:28
TP 12 - Persistence avec JPA
La persistance des données en EJB 3 a été complètement réarchitecturée au travers de JPA (Java Persistence API). Alors que
nous parlions de composants persistants en EJB 2.x, JPA se recentre sur de simples classes
Java. En EJB 2.x la persistance ne pouvait être assurée qu'à l'intérieur du conteneur alors qu'avec JPA elle peut être utilisée dans
une simple application JSE (Java Standard Edition).
Hello PetStore !
Dans le modèle de persistance JPA, un entity bean est une classe java simple (un Pojo) complétée par de simples annotations :
@Entity // 1
public class Book {
@Id // 2
private Long id;
@Column(nullable = false) // 3
private String title;
private Float price;
@Column(length = 2000) // 3
private String description;
private String isbn;
// ...
Notez la présence d'annotations à plusieurs endroits dans la classe Book :
1. tout d'abord, l'annotation @javax.persistence.Entity permet à JPA de reconnaître cette classe comme une classe
persistante et non comme une simple classe Java.
2. L'annotation @javax.persistence.Id, quant à elle, définit l'identifiant unique de l'objet. Elle donne à l'entity bean une
identité en mémoire en tant qu'objet, et en base de données via une clé primaire. Les autres attributs (description,
isbn, ...) seront rendus persistants par JPA en appliquant les paramétrages par défaut : le nom de la colonne est identique
à celui de l'attribut et le type String est converti en varchar(255).
3. L'annotation @javax.persistence.Column permet de préciser des informations sur une colonne de la table : changer son
nom (qui par défaut porte le même nom que l’attribut), préciser son type, sa taille et si la colonne autorise ou non la
valeur null.
Entity manager
Quand on veut rendre persistent en base de données un entity bean (ou une entité), il faut utiliser un entity manager. Il est
logique d'encapsuler cet entity manager dans un DAO (Data Access Object) :
public class BookDAO {
private EntityManager em;
private EntityTransaction tx;
public BookDAO() {
// Gets an entity manager and a transaction
EntityManagerFactory emf = Persistence.createEntityManagerFactory("petstorePU");
em = emf.createEntityManager();
tx = em.getTransaction(); 
}
public void persist(Book book) {
tx.begin();
em.persist(book); // 1
tx.commit();
}
Book findByISBN(String isbn) {
String queryString = "select b from Book b where b.isbn = :isbn";
Query query = em.createQuery( queryString ); // 2
query.setParameter( "isbn", isbn );
Book b = null;
b = (Book)query.getSingleResult();
return b;
}
}
L'entity manager peut notamment rendre persistant une entité par sa méthode persist() (1) ou permettre de retrouver une
entité en base en créant une requête JPQL (2)

GLG203 - TP 12 - Persistence avec JPA
Page 4 - dernière modification par Pascal GRAFFION le 2014/01/12 10:28
Contexte de persistance
L'entity manager utilise un contexte de persistance (petstorePU) qui le renseigne sur le type de la base de données et les
paramètres de connexion à cette base de données. Ces informations sont décrites dans le fichier persistence.xml :
<?xml version="1.0" encoding="UTF-8"?>
<persistence xmlns="http://java.sun.com/xml/ns/persistence" version="1.0">
<persistence-unit name="petstorePU" transaction-type="RESOURCE_LOCAL">
<provider>org.eclipse.persistence.jpa.PersistenceProvider</provider>
<class>domain.Book</class>
<properties>
<property name="eclipselink.target-database" value="MYSQL"/>
<property name="eclipselink.ddl-generation" value="drop-and-create-tables"/>
<property name="eclipselink.logging.level" value="INFO"/>
<property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver"/>
<property name="javax.persistence.jdbc.url" value="jdbc:mysql://localhost:3306/petstorejpadb"/>
<property name="javax.persistence.jdbc.user" value="root"/>
<property name="javax.persistence.jdbc.password" value=""/>
</properties>
</persistence-unit>
</persistence>
Exemple d'utilisation
Le programme ci dessous crée une instance de Book, la rend persistente puis vérifie sa présence dans la base de données :
public class Main {
public static void main(String[] args) {
// Creates an instance of book
Book book = new Book();
String isbn = "1-84023-742-2";
book.setTitle("The Hitchhiker's Guide to the Galaxy");
book.setPrice(12.5F);
// Persists the book to the database
BookDAO dao = new BookDAO();
dao.persist(book);
// Retrieve one book from the database
book = dao.findByISBN(isbn);
System.out.println("Book with isbn = " + isbn);
System.out.println(book);
Pour compiler ce programme utiliser la cible compile, pour l'exécuter utiliser la cible run. Ces cibles sont définies dans le
fichier build.xml fourni; elles requièrent la présence des 2 fichiers jar javax.persistence-2.0.0.jar et eclipselink-2.0.0.jar livrés
dans le répertoire lib.
Le fichier persistence.xml doit être trouvé lors de l'exécution; il doit être présent dans un répertoire META-INF trouvé dans le
classpath.
Ceci est assuré par la cible prepare :
<target name="prepare" depends="check">
<echo message="Setup the Yaps environment"/>
<mkdir dir="${classes.dir}"/>
<mkdir dir="${classes.dir}/META-INF"/>
<copy file="${src.dir}/META-INF/persistence.xml" todir="${classes.dir}/META-INF"/>
<mkdir dir="${build.dir}"/>
</target>
Exécution depuis Eclipse
En lançant l'exécution de ce programme depuis Eclipse, l'erreur suivante risque de s'afficher :
Exception in thread "main" javax.persistence.PersistenceException: No Persistence provider for EntityManager named
petstorePU
Pour contourner cette erreur il faudra copier le fichier Hello/src/META-INF/persistence.xml par exemple dans bin/META-
INF/persistence.xml (en supposant que bin est le "default output folder" du projet pour Eclipse (soit le répertoire dans lequel
Eclipse sauvegarde les classes compilées du projet)).

GLG203 - TP 12 - Persistence avec JPA
Page 5 - dernière modification par Pascal GRAFFION le 2014/01/12 10:28
Expression des besoins
Afin de permettre des évolutions moins couteuses de la structure de la base de données et des classes DAO associées, il a été
décidé d'utiliser JPA.
Cette nouvelle évolution est purement technique et non fonctionnelle. Il n'y a pas de nouveaux cas d'utilisation.
Analyse et conception
Vue logique
Nous allons conserver notre architecture en continuant à utiliser des DAOs.
Figure 1 - Diagramme de classe représentant les liens entre les objets du domaine et leurs DAO
Vue processus
Vue implémentation
Identique à l'étape précédente.
Architecture
Dans le diagramme de composants ci-dessous, on découvre JPA.