Utilisation de JDO dans une application web (JPox/Tomcat)

Date de publication : 20/05/2005 , Date de mise a jour : 20/05/2005

Par Benoit Moussaud (Blog)
 

Cet article fait suite au "Tutorial sur l'utilisation de JDO sur une base de donnée relationnelle". Il se propose de décrire l'intégration d'un modèle métier persisté par le driver JDO JPox au sein d'un serveur d'application Tomcat 5.x.
Téléchargez la version PDF

1. Introduction

2. Installation des composants

2.1. MySQL

2.1. JPox

2.2. Tomcat 5.x

3. Déploiement

3.1. Installation de l'application Discothèque

3.2. Paramétrage de la source de données

discotheque.xml
<Context docBase="discotheque" path="/discotheque" reloadable="true" source="com.ibm.wtp.web.server:disco">
  <Logger className="org.apache.catalina.logger.FileLogger"  prefix="localhost_discotheque_log." suffix=".txt" timestamp="true"/>
  <Resource auth="Container" name="jdbc/discoDB" type="javax.sql.DataSource"/>
  <ResourceParams name="jdbc/discoDB">
    <parameter>
      <name>factory</name>
      <value>org.apache.commons.dbcp.BasicDataSourceFactory</value>
    </parameter>
    <parameter>
      <name>username</name>
      <value>root</value>
    </parameter>
    <parameter>
      <name>password</name>
      <value/>
    </parameter>
    <parameter>
      <name>driverClassName</name>
      <value>com.mysql.jdbc.Driver</value>
    </parameter>
    <parameter>
      <name>url</name>
      <value>jdbc:mysql://localhost:3306/test?autoReconnect=true</value>
    </parameter>
  </ResourceParams>
</Context>

3.3. Création des données

Creation des données..................ok
				

3.4. Vérification des données

	3 albums de Pink Floyd, 1 de Television et le best of d'Enio Morricone
	
	Nombre d'instance de class org.moussaud.data.Album = 5
	
	Pink Floy et Television
	
	Nombre d'instance de class org.moussaud.data.Group = 2
	
	Enion Moricone, les 5 membres de PF
	
	Nombre d'instance de class org.moussaud.data.Person = 6
	
	Groupe + Person
	
	Nombre d'instance de class org.moussaud.data.Artist = 8
	
	Tracks
	
	Nombre d'instance de class org.moussaud.data.Track = 38
	
	Genre: rock, blues
	
	Nombre d'instance de class org.moussaud.data.Genre = 2
				

3.5. Requêtes

Liste des Albums (non triés)

    * The Wall - rock
    * Dark Side Of The Moon - rock
    * Wish you Were Here - rock
    * Marquee Moon - rock
    * Compilation - Blues

Liste des Albums (triés)

    * Compilation - Blues
    * Dark Side Of The Moon - rock
    * Marquee Moon - rock
    * The Wall - rock
    * Wish you Were Here - rock
				

4. Creusons !

• l'accès au persistence manager et
• la nouvelle fonctionnalité de JDO 2.0, détachement et attachement des objets.

4.1. Conception de "Discothèque"

Conception

4.2. L'accès au persistence manager

1. de charger les propriétés JDO / JPox
2. de créer une instance de la classe PersistenceManagerFactory
3. d'ouvrir une instance de la classe PersistanceManager

PMHelper
package org.moussaud.service;

import javax.jdo.JDOHelper;
import javax.jdo.PersistenceManager;
import javax.jdo.PersistenceManagerFactory;

public class PMHelper {

	private static final ThreadLocal pms = new ThreadLocal();

	private static PersistenceManagerFactory pmf = null;

	public static PersistenceManager currentPM() {

		PersistenceManager pm = (PersistenceManager) pms.get();
		if (pm == null) {
			pm = getPMF().getPersistenceManager();
			pms.set(pm);
		}
		return pm;
	}

	public static void closePM() {
		PersistenceManager pm = (PersistenceManager) pms.get();
		pms.set(null);
		if (pm != null)
			pm.close();
	}

	private static PersistenceManagerFactory getPMF() {
		if (pmf == null) {
			pmf = JDOHelper.getPersistenceManagerFactory(Utils
					.getJDOProperties());
		}
		return pmf;
	}
}

4.3. Détachement des objets

4.3.1. La requête

public Collection sortData(boolean sorted) {
	try {

		PersistenceManagerFactory pmf = JDOHelper
				.getPersistenceManagerFactory(Utils.getJDOProperties());
		PersistenceManager pm = pmf.getPersistenceManager();
		Transaction tx = pm.currentTransaction();
		pm.getFetchPlan().addGroup("detach_album_genre");
		tx.begin();
		Query qt = pm.newQuery(Album.class);
		if (sorted)
			qt.setOrdering("name ascending");
		Collection c = (Collection) qt.execute();
		c = pm.detachCopyAll(c);
		tx.commit();

		return c;
	} finally {
		PMHelper.closePM();
	}
}

• pm.getFetchPlan().addGroup("detach_album_genre"). Cette ligne indique au persistence manager que l'on va ajouter au plan de récupération par défaut d'autres instances. Par défaut, quand un objet est récupéré par le persistence manager, le driver s'arrête à ce que j'appele les types simples ou basiques. Toutes relations de type 1..1 ou 1..n ne sont pas du tout récupérées. Elles le seront à la demande. Dans notre exemple nous allons augmenter la récupération par défaut en y incluant une relation 1..1 vers la classe Genre
• c = pm.detachCopyAll(c) Cette methode permet de détacher les instances d'une collection du PersistenceManager avec laquelle elles sont liées. (en concordance avec le plan de récupération - le fetch plan).

4.3.2. Définition du plan de récupération (Fetch Plan)

<class name="Album" detachable="true" identity-type="datastore">
  <field name="artist"/>
  <field name="date"/>
  <field name="genre"/>
  <field name="name"/>
  <!-- relation 1..n implementee sous forme de List (arraylist)
  contenant des instances de la classe Track -->
  <field name="tracks">
    <collection element-type="org.moussaud.data.Track"/>
    <join/>
  </field>
  <!-- Definition d'un fetch groupe qui contient les pistes -->
  <fetch-group name="detach_album_genre">
    <field name="genre"/>
  </fetch-group>
  <!-- Definition d'un fetch groupe qui contient l'artiste et le genre -->
  <fetch-group name="all_details">
    <field name="artist"/>
    <field name="genre"/>
    <field name="tracks"/>
  </fetch-group>
</class>

• Cas d'utilisation 1: Requête pour afficher le nom des albums (fetch group defaut) puis
• Cas d'utilisation 2: Détail d'un album (fetch group all_details, ajout des attributs artists,genre et tracks)

5. Conclusion

Une étape supplémentaire pour une conception complète serait d'y ajouter l'utilisation du framework . Spring permet de prendre en charge

• la gestion du persistence manager et de sa factory,
• la gestion des transactions de façon déclarative (comme dans EJB)
• de l'assemblage des différentes couches (web, services, métiers, données)

5.1. Crédits et License

Ce tutorial est écrit par Benoit Moussaud, Consultant Sénior en Architecture J2EE chez Xebia
Pour un contact ou des précisions, n'hésitez pas à m'écrire: bmoussaud@xebia.fr
Copyrights Benoit Moussaud 2005