Découverte du langage HQL - Mistra

Découverte du langage HQL
Nous savons désormais comment enregistrer une entité JPA dans la base de données.
Découvrons maintenant comment manipuler notre objet grâce aux opérations de récupération,
modification et suppression. Pour ce faire, nous allons d'abord créer une classe de tests dans
laquelle nous testerons successivement ces opérations.
La préparation de cette classe nous permettra de découvrir les premiers éléments du langage
de requêtage propre à Hibernate, le langage HQL (Hibernate Query Language), que nous
approfondirons ensuite dans le chapitre suivant.Le langage HQL possède une syntaxe proche
du SQL et permet d'écrire des requêtes dans un langage simplifié et adapté à la manipulation
orientée objet.
Création de la classe de tests
Commençons par créer une nouvelle classe Main, dans laquelle nous effectuerons nos tests
successifs.
Mistra Formation - 19 rue Béranger 75003 Paris - Métro République - 01 82 52 25 25 - [email protected]
Découverte du langage HQL
Cette classe sera composée des méthodes suivantes :
private static void clean() : vide la table EVENTS entre deux tests,
private static void print() : affiche le contenu de la table EVENTS entre deux tests,
private static void testCreate() : crée deux objets Event et les enregistre dans la base
de données,
private static void testRead() : récupère un objet Event à partir de son titre,
private static void testUpdate() : récupère un objet Event dans la base de données, le
modifie, puis rend persistantes les modifications,
private static void testDelete() : supprime un objet Event présent dans la base de
données.
Enfin, une méthode main() initialise la session Hibernate, puis appelle successivement les
méthodes de test.
import org.hibernate.Session;
public class Main {
private static Session s = null;
Mistra Formation - 19 rue Béranger 75003 Paris - Métro République - 01 82 52 25 25 - [email protected]
Découverte du langage HQL
public static void main(String[] args) {
// Ouverture d'une session Hibernate
s = HibernateUtils.getSession();
// Lancement des tests successifs
testCreate();
testRead();
testUpdate();
testDelete();
// Fermeture de la session Hibernate
s.close();
}
// Création d'un event
private static void testCreate() {
}
// Lecture d'un event
Mistra Formation - 19 rue Béranger 75003 Paris - Métro République - 01 82 52 25 25 - [email protected]
Découverte du langage HQL
private static void testRead() {
}
// Modification d'un event
private static void testUpdate() {
}
// Suppression d'un event
private static void testDelete() {
}
// Vide la table EVENTS de toutes ses entrées
private static void clean() {
}
// Affiche le contenu de la table EVENTS
private static void print() {
}
}
Mistra Formation - 19 rue Béranger 75003 Paris - Métro République - 01 82 52 25 25 - [email protected]
Découverte du langage HQL
Afficher et vider la table EVENTS
Vider la table EVENTS
Commençons par la méthode clean() qui vide la table EVENTS de tout son contenu.Comme
nous l'avons vu précédemment, une opération effectuant une modification sur les données
persistantes commence par l'ouverture d'une transaction et se termine par la fermeture de
celle-ci.
Entre les deux, nous utiliserons une requête Hibernate (classe org.hibernate.Query), écrite en
HQL : "delete Event".
import java.util.Calendar;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.Transaction;
// Vide la table EVENTS de toutes ses entrées
private static void clean() {
System.out.println("--------- Vide la table events : ---------");
// Début de la transaction
Transaction tx = s.beginTransaction();
Mistra Formation - 19 rue Béranger 75003 Paris - Métro République - 01 82 52 25 25 - [email protected]
Découverte du langage HQL
// Création de la requête
Query q = s.createQuery("delete Event");
// Exécution de la requête
q.executeUpdate();
// Fin de la transaction
tx.commit();
}
Nous retrouvons bien, lignes 8 et 16, la gestion de la transaction. Le HQL est utilisé ligne 11
pour la suppression de tout le contenu de la table stockant les events.
Notons que la table est désignée par le nom de l'entité JPA Event et non par le nom de la table
dans la base de données, events. En effet, le HQL est orienté objet et est prévu pour faciliter la
transition avec le modèle objet Java.
Ligne 13, nous appelons la méthode permettant de lancer l'exécution de la requête.
Afficher le contenu de la table EVENTS
Afin de vérifier le résultat de chacun de nos tests de façon plus rapide qu'en vérifiant sur
PhpMyAdmin, nous allons écrire une méthode affichant le contenu de la table events.
import java.util.ArrayList;
import java.util.Calendar;
Mistra Formation - 19 rue Béranger 75003 Paris - Métro République - 01 82 52 25 25 - [email protected]
Découverte du langage HQL
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.Transaction;
import fr.mistra.pgejpav1.jpa.Event;
// Affiche le contenu de la table EVENTS
private static void print() {
// Début de la transaction
Transaction tx = s.beginTransaction();
// Création de la requête
Query q = s.createQuery("from Event");
// Récupération de la liste des résultats
ArrayList list = (ArrayList) q.list();
// Affichage des résultats
for (Event e: list) {
System.out.println("Event : [id] = " + e.getId() + "\t" +
"[title] = " + e.getTitle() + "\t" +
"[desc] = " + e.getDescription() + "\n" +
Mistra Formation - 19 rue Béranger 75003 Paris - Métro République - 01 82 52 25 25 - [email protected]
Découverte du langage HQL
"[date] = " + e.getBeginDate().getTime().toLocaleString() + "\t" +
"[allDay] = " + e.isAllDay());
}
// Fin de la transaction
tx.commit();
}
Là encore, nous ouvrons et fermons une transaction Hibernate en début et fin de méthode.
La requête HQL se compose simplement avec "from Event" (ligne 17): la clause SELECT du
SQL est sous-entendue. Le résultat, sous forme de java.util.List est obtenu grâce à la méthode
list() de la classe Query (ligne 19).
Enfin, les lignes 21 à 27 gèrent l'affichage des entrées lues, champ par champ.
Test des méthodes de suppression et d'affichage
Testons ces deux méthodes à l'aide du code suivant :
import org.hibernate.Session;
public static void main(String[] args) {
// Ouverture d'une session Hibernate
s = HibernateUtils.getSession();
Mistra Formation - 19 rue Béranger 75003 Paris - Métro République - 01 82 52 25 25 - [email protected]
Découverte du langage HQL
// Vide la table EVENTS de ses éventuelles entrées
clean();
// Affiche le contenu de la table
print();
// Fermeture de la session Hibernate
s.close();
}
A l'exécution du programme, les habituels logs Hibernate s'affichent dans la console, suivi des
traces d'exécution suivantes :
--------- Vide la table events : --------Hibernate:
delete
from
events_01
Hibernate:
/*
from
Mistra Formation - 19 rue Béranger 75003 Paris - Métro République - 01 82 52 25 25 - [email protected]
Découverte du langage HQL
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_
Le log Hibernate de la méthode clean() (lignes 3 à 5) montrent que la requête HQL que nous
avions écrite s.createQuery("delete Event"); est bien traduite en la requête SQL
correspondante, et que le lien entre la classe Event et la table events_01 est bien effectué.
De même dans la méthode print() aux lignes 10 à 17 : s.createQuery("from Event") est bien
traduit en select from events_01.
Notre classe de tests est prête, nous pouvons désormais implémenter les tests des opérations
élémentaires de manipulation d'objets. Ces opérations sont souvent appelées opérations
CRUD, pour Create - Read - Update - Delete : création, récupération modification et
suppression.
Mistra Formation - 19 rue Béranger 75003 Paris - Métro République - 01 82 52 25 25 - [email protected]
Découverte du langage HQL
.
Mistra Formation - 19 rue Béranger 75003 Paris - Métro République - 01 82 52 25 25 - [email protected]
Powered by TCPDF (www.tcpdf.org)