Enregistrer un nouvel évènement

Transcription

1 Maintenant que nous avons géré les utilisateurs, voyons l'enregistrement d'un nouvel évènement créé par l'utilisateur qui sera connecté au client. Là encore, nous utiliserons une couche DAO formée d'une interface, nommée EventDAO, et de son implémentation Hibernate, nommée EventDAOHibernate, ainsi qu'une couche de services constituée d'une classe EventServices. Arborescence du projet La nouvelle arborescence du projet est donc la suivante :

2 Implémentation de la couche DAO L'interface EventDAO est composée uniquement d'une méthode makepersistant() qui renvoie l'entité rendue persistante ou null si la sauvegarde a rencontré un quelconque problème :?package fr.mistra.pgejee.dao; import fr.mistra.pgejpa.model.event;

3 public interface EventDAO { // Enregistre dans la base de données l'entité passée en paramètre public abstract User makepersistent(event entity); Nous y ajouterons des méthodes supplémentaires par la suite, notamment lorsque nous voudrons récupérer des évènements pour les afficher. Voyons maintenant l'implémentation Hibernate de cette interface : package fr.mistra.pgejee.dao; import org.hibernate.query; import org.hibernate.session; import org.hibernate.transaction; import fr.mistra.pgejpa.model.event; import fr.mistra.pgejpa.utils.hibernateutils; public class EventDAOHibernate implements EventDAO { private Session s = null;

4 // Enregistre dans la base de données l'entité passée en paramètre public User makepersistent(event entity) { // Récupération d'une session Hibernate if(s == null) s = HibernateUtils.getSession(); // Début de la transaction Hibernate Transaction tx = s.begintransaction(); Event e = null; // Si l'entité possède un identifiant, on teste si elle est persistante if (entity.getid()!= null && entity.getid()!= 0) { // On cherche en base de données s'il existe déjà un event avec le même id Query q = s.createquery("from Event e where e.id=:id").setinteger("id", entity.getid()); e = (Event) q.uniqueresult(); // Sauvegarde d'une entité non persistante if (e == null)

5 s.save(entity); // Merge d'une entité déjà persistante else entity = s.merge(entity); // Fin de la transaction tx.commit(); // Retourne l'identifiant de l'entité sauvegardée return entity; Dans la liste les fonctionnalités à implémenter, nous avons inclus la modification d'un évènement. Mais pour modifier un évènement, encore faut-il l'avoir au préalable récupéré depuis la base de données pour ensuite effectuer les modifications et les enregistrer. Nous pourrons ainsi avoir à rendre persistant un évènement récupéré depuis la base de données et par conséquent possédant déjà un identifiant : dans ce cas, la méthode Hibernate à utiliser ne sera plus save() mais merge(). Il nous faut donc distinguer ce cas de modification de celui de la première sauvegarde d'un évènement venant tout juste d'être créé. Pour rendre persistant un évènement, nous suivons donc les étapes suivantes :

6 ouverture d'une session et création d'une transaction Hibernate (lignes 17 à 21), récupération, depuis la base de données, de l'évènement possédant le même identifiant que l'entité à sauvegarder (lignes 23 à 31), si l'entité à sauvegarder est transiente (première sauvegarde), nous utilisons la méthode save (lignes 34-35), sinon, il faut appeler la méthode merge (lignes ), dans tous les cas, la transaction est ensuite fermée pour synchroniser le contexte de persistance avec la base de données (ligne 41) et l'entité désormais persistante est renvoyée (ligne 43) Implémentation de la couche de services Voyons maintenant la classe EventService. Elle contiendra, pour l'instant tout du moins, une unique méthode saveevent() correspondant au code ci-dessous : package fr.mistra.pgejee.services; import fr.mistra.pgejee.dao.eventdao; import fr.mistra.pgejee.utils.factory; import fr.mistra.pgejpa.model.event; public class EventServices { private EventDAO edao = Factory.getEventDAO(); // Sauvegarde l'évènement passé en paramètre

7 public Event saveevent(event entity) { return edao.makepersistent(entity); La méthode saveevent() nécessite un attribut EventDAO (ligne 12). Nous utilisons donc la Factory et sa méthode geteventdao() (ligne 8) pour assurer l'indépendance entre EventServices et l'implémentation Hibernate de EventDAO : // Fournit une implémentation de l'interface EventDAO public static EventDAO geteventdao() { return new EventDAOHibernate(); Test de l'implémentation L'enregistrement d'un nouvel évènement est désormais fonctionnel : pour le vérifier, complétons la classe Main en y ajoutant une méthode de test : package fr.mistra.pgejee.tests; import java.util.arraylist; import java.util.list; import fr.mistra.pgejee.services.eventservices;

8 import fr.mistra.pgejee.services.userservices; import fr.mistra.pgejpa.model.address; import fr.mistra.pgejpa.model.event; import fr.mistra.pgejpa.model.user; public class Main { private static UserServices uservices = new UserServices(); private static EventServices eservices = new EventServices(); public static void main(string[] args) { testsaveuser(); testgetuserbylogin(); testconnectuser(); testsaveevent(); public static void testsaveevent() { System.out.println(" testsaveevent() "); // Création de l'évènement

9 User owner = uservices.getuserbylogin("mistra"); Event e = new Event("Titre", "description", false); e.setuser(owner); // Enregistrement de évènement e = eservices.saveevent(e); System.out.println("Evènement sauvé : " + e.gettitle()); // Modification de l'évènement e.settitle("titre modifié"); e = eservices.saveevent(e); System.out.println("Evènement modifié : " + e.gettitle()); public static void testconnectuser() { // Voir implementation au chapitre précédent public static void testgetuserbylogin() { // Voir implementation au chapitre précédent

10 public static void testsaveuser() { // Voir implementation au chapitre précédent Notez que l'utilisation judicieuse des Cascade lors de la réalisation de la couche de persistance (voir chapitres Relation one-to-one et Relation many-to-one du tutoriel Hibernate) nous affranchit de toute gestion particulière de l'attribut User lors de l'enregistrement d'un objet Event : la cascade fait en sorte que la sauvegarde d'un Event entraine la sauvegarde ou la mise à jour de l'user associé. Il en va de même pour Address : en effet, dans ces deux cas, c'est la classe Event qui est maitresse de l'association. Par contre, dans les associations entre Event et Item et entre Event et Guest, Event n'est pas le côté maitre de l'association. Pour pouvoir rendre persistant une entité Event et cascader la persistance sur ses listes d'items et de Guests, il nous faut : rendre persistante l'entité Event, y associer les listes d'items et de Guests, rendre persistante à nouveau l'entité Event. Les entités Items et Guests seront rendues persistantes et les associations seront mises à jour lors du deuxième appel à makepersistant() comme illustré dans le test ci-dessous : package fr.mistra.pgejee.tests;

11 import java.util.arraylist; import java.util.list; import fr.mistra.pgejee.services.eventservices; import fr.mistra.pgejee.services.userservices; import fr.mistra.pgejpa.model.address; import fr.mistra.pgejpa.model.event; import fr.mistra.pgejpa.model.guest; import fr.mistra.pgejpa.model.item; import fr.mistra.pgejpa.model.user; public class Main { private static UserServices uservices = new UserServices(); private static EventServices eservices = new EventServices(); public static void main(string[] args) { testsaveuser(); testgetuserbylogin(); testconnectuser(); testsaveevent();

12 testsaveeventwithassociations(); public static void testsaveeventwithassociations() { System.out.println(" testsaveeventwithassociations() "); // Création de l'évènement User u = uservices.getuserbylogin("tutoriel"); Address a = new Address("Domicile", "rue des cerisiers", "75001", "Paris"); Event e = new Event("Evènement", "Description de l'évènement", false); e.setuser(u); e.setaddress(a); // Enregistrement de l'évènement e = eservices.saveevent(e); System.out.println("Evènement sauvé : " + e.gettitle()); // Création des listes de courses et d'invités Item i = new Item("jus d'orange", 3, 0); Item i2 = new Item("pistaches", 2, 1);

13 Guest g = new Guest("invité", "invité(a)mistra.fr"); Guest g2= new Guest("guest", " (a)mistra.fr"); // Gestion des associations i.setevent(e); i2.setevent(e); List itemlist = new ArrayList() ; itemlist.add(i); itemlist.add(i2); e.setitemlist(itemlist); List guestlist = new ArrayList() ; guestlist.add(g); guestlist.add(g2); e.setguestlist(guestlist); List eventlist = new ArrayList() ; eventlist.add(e); g.setevents(eventlist);

14 g2.setevents(eventlist); // Sauvegarde des associations ajoutées e = eservices.saveevent(e); System.out.println("Evènement modifié : " + e.gettitle()); public static void testsaveevent() { // Voir implémentation ci-dessus public static void testconnectuser() { // Voir implémentation au chapitre précédent public static void testgetuserbylogin() { // Voir implémentation au chapitre précédent public static void testsaveuser() {

15 Powered by TCPDF ( Enregistrer un nouvel évènement // Voir implémentation au chapitre précédent L'ensemble des entités rendues persistantes peuvent être parcourues avec l'outil PhpMyAdmin fourni par WampServer. La récupération des évènements depuis la base de données constitue justement la prochaine fonctionnalité que nous devons implémenter. Mais avant cela, prenons tout d'abord le temps de découvrir et comprendre l'importance d'un nouveau design pattern : les Data Transfer Objects, souvent abrégés en DTO.