Manipulation d`objets et opérations CRUD

Transcription

Manipulation d'objets et opérations CRUD
Nous avons vu précédemment quelques opérations sur la base de données : l'insertion d'une
entrée dans le chapitre Génération de la base de données, ainsi que la récupération et la
suppression des données de toute une table dans le chapitre Découverte du langage HQL.
Reprenons la classe Main commencée dans le chapitre précédent avant de compléter les
fonctions de tests :
import org.hibernate.Session;
public static void main(String[] args) {
// Ouverture d'une session Hibernate
s = HibernateUtils.getSession();
// Vide la table EVENTS de ses éventuelles entrées
clean();
// Lancement des tests successifs
testCreate();
testRead();
testUpdate();
Mistra Formation - 19 rue Béranger 75003 Paris - Métro République - 01 82 52 25 25 - [email protected]
testDelete();
// Fermeture de la session Hibernate
s.close();
}
Création d'un objet
Code Hibernate
import java.util.Calendar;
import org.hibernate.Query;
import org.hibernate.Transaction;
import fr.mistra.pgejpav1.jpa.Event;
// Création d'un event
private static void testCreate() {
System.out.println("--------- testCreate ---------");
// Création des objets à sauvegarder
Event e1 = new Event();
e1.setTitle("Titre du premier évènement");
e1.setDescription("Description 1");
e1.setBeginDate(Calendar.getInstance());
e1.setAllDay(true);
Event e2 = new Event();
e2.setTitle("Deuxième évènement");
e2.setDescription("Description du deuxième évènement");
e2.setBeginDate(Calendar.getInstance());
e2.setAllDay(false);
// Début de la transaction
Transaction tx = s.beginTransaction();
// Sauvegarde des objets
s.save(e1);
s.save(e2);
// Fermeture de la transaction
tx.commit();
// Affiche le contenu de la table EVENTS
print();
}
Comme toujours, nous débutons une transaction (ligne 25) avant toute opération sur la base de
données, et la fermons une fois celles-ci terminées (ligne 30). Les opérations de sauvegarde
s'effectue à l'aide de la méthode save() de la session Hibernate (lignes 27 et 28).
Lancement du test
Lançons le programme et observons les traces d'exécution affichées :
--------- Vide la table events : --------Hibernate:
delete
from
events_01
--------- testCreate --------Hibernate:
/* insert fr.mistra.pgejpav1.jpa.Event
*/ insert
into
events_01
(events_allDay, events_beginDate, events_description, events_title)
values
(?, ?, ?, ?)
Hibernate:
/* insert fr.mistra.pgejpav1.jpa.Event
*/ insert
into
events_01
(events_allDay, events_beginDate, events_description, events_title)
values
(?, ?, ?, ?)
--------- Contenu de la table events : --------Hibernate:
/*
from
Event */ select
event0_.events_id as events1_0_,
event0_.events_allDay as events2_0_,
event0_.events_beginDate as events3_0_,
event0_.events_description as events4_0_,
event0_.events_title as events5_0_
from
events_01 event0_
Event : [id] = 1 [title] = Titre du premier évènement [desc] = Description 1 [date] = 13 juil. 2010
10:56:31 [allDay] = true
Event : [id] = 2 [title] = Deuxième évènement [desc] = Description du deuxième évènement
[date] = 13 juil. 2010 10:56:31 [allDay] = false
Lignes 8 à 14, nous pouvons observer la traduction de la méthode save() d'Hibernate en la
requête SQL insert into.
L'effet de cette insertion (et de celle qui la suit) se vérifient grâce à notre méthode clean : les
lignes 35 et 36 rapportent la liste des entrées présentes dans la table events, qui correspondent
bien aux deux objets que nous voulions ajouter.
Récupération d'un objet
Maintenant que nous savons comment ajouter un objet, voyons comment le récupérer depuis la
base de données pour l'utiliser dans le programme Java.
Pour ce faire, complétons la méthode testRead(). Ici, il n'est pas nécessaire d'utiliser une
transaction: étant donné qu'aucune modification n'est faite sur la base de données, aucune
synchronisation n'est nécessaire.
Nous allons utiliser une requête HQL permettant de faire un select contenant une clause where.
Nous avons choisi ici de récupérer l'objet Event dont le titre est "Titre du premier évènement",
mais le code peut être modifié pour porter sur n'importe quel attribut de la classe.
Code Hibernate
import java.util.Calendar;
// Lecture d'un event
private static void testRead() {
System.out.println("--------- testRead ---------");
// Récupération de l'Event d'après son titre
Query q = s.createQuery("from Event where title= :myTitle");
q.setString("myTitle", "Titre du premier évènement");
Event e = (Event) q.uniqueResult();
// Affichage de l'objet récupéré
System.out.println("Event : [id] = " + e.getId() + "\t" +
"[title] = " + e.getTitle() + "\t" +
"[desc] = " + e.getDescription() + "\t" +
"[date] = " + e.getBeginDate().getTime().toLocaleString() + "\t" +
"[allDay] = " + e.isAllDay());
}
Arrêtons-nous plus longuement sur les lignes 11 à 13. La requête SQL que l'on cherche à écrire
est : select from events where events_title = "Titre du premier évènement";
La partie fixe, "select from events where events_title =", se traduit en HQL par : from Event
where title =En effet, le HQL est un langage de requêtage orienté objet: nous utilisons donc les
noms des entités et des attributs et non ceux des tables et des colonnes (ligne 12).
La partie variable comportant le titre que l'on recherche est introduite dans la requête par
l'insertion de la variable :myTitle. Notez les deux points qui permettent d'indiquer que c'est un
paramètre dont la valeur doit être précisé. Pour la préciser, nous utilisons la méthode setString
(ligne 13), prenant en paramètre deux chaines de caractères : la première correspond au nom
du paramètre (ici myTitle), la deuxième à la valeur de celui-ci.
Enfin, nous récupérons le résultat de cette requête à l'aide de la méthode uniqueResult().
Précédemment, dans la méthode print(), nous avions utilisé la méthode list() pour récupérer une
liste de résultats. Ici, nous savons qu'il n'existe qu'une seule entrée dont le titre est celui passé
en paramètre de la requête. Nous pouvons donc utiliser la méthode uniqueResult() en castant
le résultat en Event.
Lancement du test
Lors de l'exécution, l'objet récupéré est affiché grâce aux lignes 15 à 20:
--------- testRead --------Hibernate:
/*
from
Event
where
title= :myTitle */ select
event0_.events_id as events1_0_,
event0_.events_allDay as events2_0_,
event0_.events_beginDate as events3_0_,
event0_.events_description as events4_0_,
event0_.events_title as events5_0_
from
events_01 event0_
where
event0_.events_title=?
Event : [id] = 1 [title] = Titre du premier évènement
2010 11:53:44 [allDay] = true
[desc] = Description 1 [date] = 13 juil.
Modification d'un objet
Code source de la méthode
Découvrons maintenant comment modifier un objet préalablement présent en base de données
et enregistrer cette modification :
// Modification d'un event
private static void testUpdate() {
System.out.println("--------- testUpdate ---------");
System.out.println("Avant modification");
print();
// Modifications des attributs de l'objet
e.setDescription("Description modifiée");
e.setAllDay(false);
// Prise en compte de la modification
s.update(e);
tx.commit();
System.out.println("Après modification");
print();
}
Jusqu'à la ligne 19, rien de nouveau, nous récupérons un objet provenant de la base de
données et modifions certains de ses attributs. Ligne 22, nous débutons la désormais
traditionnelle transition Hibernate, puisque les modifications à prendre en compte nécessitent
une synchronisation avec la base de données.
Pour enregistrer une modification, la session Hibernate fournit une méthode update(), à laquelle
est fournie en paramètre l'objet à mettre à jour (ligne 23). Enfin, le commit() de la ligne 24
synchronise l'objet modifié.
Lancement du test
Pour vérifier le bon fonctionnement de la modification, les traces d'exécution affichent le
contenu de la table avant et après la modification de l'objet:
--------- testUpdate --------Avant modification
2010 12:06:13 [allDay] = true
[desc] = Description 1 [date] = 13 juil.
Après modification
13 juil. 2010 12:06:13 [allDay] = false
[desc] = Description modifiée
[date] =
Suppression d'un objet
Code source de la méthode
La dernière opération CRUD à réaliser est la suppression d'un objet dans la base de données.
Pour ce faire, nous allons procéder de façon similaire à la modification, hormis le fait que l'appel
à la méthode update() est remplacé par un appel à la méthode delete(), appartenant elle aussi
à la session Hibernate:
// Suppression d'un event
private static void testDelete() {
System.out.println("--------- testDelete ---------");
System.out.println("Avant suppression");
print();
// Enregistrement de la suppression
s.delete(e);
tx.commit();
System.out.println("Après suppression");
print();
}
Lancement du test
Là encore, les traces d'exécution nous permettent de contrôler le bon fonctionnement de notre
test :
--------- testDelete --------Avant suppression
13 juil. 2010 14:20:29 [allDay] = false
[desc] = Description modifiée
[date] =
Après suppression
Arrivé à ce point du tutoriel, nous savons désormais comment mapper une classe et comment
manipuler les objets mappés. Mais un projet utilisant Hibernate nécessite bien évidemment
plusieurs classes, souvent liées entre elles par diverses associations, qu'il faut elles aussi
mapper et transformer en clés étrangères ou en tables de jointure. C'est notamment le cas de
l'étude de cas que nous vous proposons.
Hibernate possède des annotations différentes selon le type d'association (1--1, 1--n, n--n),
nous allons donc les découvrir au fur et à mesure du développement de notre projet.
.
Powered by TCPDF (www.tcpdf.org)

Manipulation d`objets et opérations CRUD

Transcription

Documents pareils

Demander un CIF

Ecran d`accueil du CD d`installation Debian

Journée Scientifique de l`Association Française de la Recherche sur

Survitopia EVENT - Dessiner c`est gagné ?

Become Event Manager

Aquarium de Paris

Télécharger la bibliographie de Loïse Lenne

Business development event

Séquence de démarrage

Manos Premier Hotel