AFIA Amine ╫ ZOHAYR Nadia ╫ CHATIR Imane

╫ BARQANE Meriem ╫ NAJIMI Najoua

Réalisé par :

création

mise en route

Manipulation

Plan

La création

o Problématiqueo Mapping Objet/Relationnelo Qu’est ce que hibernate?o Configuration du projet hibernate

Problématique

L’utilisation du JDBC (Java DataBase Connectivity) implique que le développeur implémente lui-même l'interaction avec les bases de données et les requêtes SQL qui sont nécessaires à la persistance des données de son application.

mapping Objet/Relationnel

La technique du mapping relationnel-objet (également appelé ORM pour Object Relational Mapping) permet de faire le lien entre le modèle des classes et le schéma relationnel et de réaliser les transcriptions nécessaires au passage de l’objet vers le relationnel.

Solution

mapping Objet/Relationnel

Grace à cette notion de mapping le temps de développement de l’application est réduit, en éliminant une grande partie du code SQL à écrire pour interagir avec la base de données.

Solution

mapping Objet/Relationnel

Cette technique permet ainsi de faire automatiquement les transcriptions suivantes:

Mode objet Mode relationnel

classe table

instance enregistrement

attribut colonne

association Clé étrangère

Solution

Qu’est ce que l’hibernate?

Hibernate est un outil de mapping Objet/Relationnel. C’est un framework open source qui permet de faire correspondre des tables de base de données relationnelles avec des objets java.

Qu’est ce que l’hibernate?

Hibernate permet de gérer les transactions coté base de données, et de manipuler facilement les données et assurer leur persistance au niveau de la base de données.

Les surplus de hibernate

• hibernate se charge de générer le code SQL.

• récupération de données optimisée.

• portabilité du code si changement de base de données.

Hibernate a besoin de plusieurs éléments pour fonctionner :

• Configuration du projet Eclipse.

• Une classe javabean qui encapsule les données d'une occurrence de table.

• Un fichier de configuration qui assure la correspondance entre la classe et la table (mapping).

Configuration d’un projet hibernate

1. Etablir la connexion entre MySql et Eclipse.

2. Etablir la connexion entre Hibernate et Eclipse.

3. Etablir la connexion entre Hibernate et MySql.

La mise en route

o Création entité jpao Configuration hibernateo Contexte de persistance et sessionso Génération de base de donnée

Création entité jpa

• Créer une classe qui va encapsuler les données Cette classe doit respecter le standard des Javabeans, notamment, encapsuler les propriétés dans ses champs private avec des getters et setters et avoir un constructeur par défaut.

• Afin que JPA puisse faire le lien entre un objet Java et la base de données, les classes à mapper sont définies en tant qu’entité JPA. Pour ce faire, on les déclare avec l'annotation @Entity. Elle doit également comporter au moins un attribut déclaré comme clé primaire à l'aide de l'annotation @Id.

Création entité jpa

Premier mapping

• Comme nous l’avons vu, la classe est déclarée avec l’annotation @Entity , qui indique que la classe est une entité JPA et qu’elle doit donc être mappée .

• La norme de l’API JPA nécessite également que l’on précise quel est l’id de la table . L’annotation @GeneratedValue indique à l’API comment gérer l’incrément des identifiants. Ici, nous avons choisi un incrément automatique.

• Ajoutons maintenant quelques annotations supplémentaires pour préciser le mapping que nous désirons. Toutes ces nouvelles annotations sont facultatives, mais souvent nécessaires : dans notre exemple, nous avons notamment besoin de préciser que l'attribut beginDate est de type DATE et non DATETIME.

Des annotations supplémentaires

• En supplément de l’annotation @Entity, la JPA propose de préciser le nom de la table en utilisant l’annotation @Table .

• Pour chaque attribut, l’annotation @Column indique le nom que l’on désire donner au champ dans la table.

Configuration d'Hibernate• Notre première entité JPA étant désormais écrite, il

faut maintenant paramétrer Hibernate pour qu’il puisse se connecter à notre base de données.

• Avant toute chose, il est à noter qu’Hibernate est capable de créer des tables et de faire toutes sortes d’opérations sur celles-ci ainsi que sur leurs entrées. Toutefois, la base de données en elle-même doit préalablement exister, et donc avoir été créée manuellement.

• Pour créer la base de données, utilisons l’outil PhpMyAdmin fourni par Wamp Server.

Pour exécuter Hibernate, il faut lui fournir un certain nombre de propriétés concernant sa configuration pour qu'il puisse se connecter à la base de données.

• Ces propriétés peuvent être fournies sous plusieurs formes :

• un fichier de configuration nommé hibernate.properties et stocké dans un répertoire inclus dans le classpath

• un fichier de configuration au format XML nommé hibernate.cfg.xml

• utiliser la méthode setProperties() de la classe Configuration

• définir des propriétés dans la JVM en utilisant l'option -Dpropriété=valeur

Les principales propriétés pour configurer la connexion JDBC sont :

• hibernate.connection.driver_class: nom pleinement qualifié de la classe du pilote JDBC• hibernate.connection.url : URL JDBC désignant la base de données• hibernate.connection.username: nom de l'utilisateur pour la connexion• hibernate.connection.password : mot de passe de l'utilisateur

nous précisons qu’à l’initialisation d’Hibernate, les

tables correspondant aux entités mappées doivent être créées. Différentes valeurs sont possibles pour ce paramètre hbm2ddl.auto :

• validate: valide le schéma, aucune modification n’est faite sur la structure de la base ;

• update: met à jour le schéma existant ;• create: crée le schéma en supprimant les données

préalablement existantes ;• create-drop: même comportement que create avec

suppression du schéma en fin de session.

Contexte de persistance et sessions

Pour utiliser Hibernate dans le code, il est nécessaire de réaliser plusieurs opérations :

• création d'une instance de la classe• création d'une instance de la classe SessionFactory• création d'une instance de la classe Session qui va

permettre d'utiliser les services d'Hibernate

• Pour gérer les accès à la base de données, Hibernate utilise des sessions. Ce sont des instances de la classe org.hibernate.session qui permettent d'encapsuler une connexion JDBC.

• Les sessions sont créées par une instance de la classe

SessionFactory, dont le rôle est de parser le fichier de configuration Hibernate, de se connecter à la base de données et de fournir des Sessions à la demande. Habituellement, une seule instance de SessionFactory est créée dans toute l'application.

• nous allons créer une classe HibernateUtils chargée de créer et de gérer la SessionFactory. La méthode getSession() de cette classe sera appelée à chaque fois que nous voudrons accéder à la base de données.

• La SessionFactory instanciée se charge de lire le fichier hibernate.cfg.xml et d’initialiser Hibernate pour une utilisation ultérieure., la méthode getSession() utilise la sessionFactory pour créer une nouvelle session Hibernate, que nous pourrons alors utiliser pour accéder à la base de données.

• Notons que nous effectuons ici les premiers imports spécifiques à Hibernate. L’entité JPA , elle, ne dépend jamais d’Hibernate mais seulement de javax.persistence. De cette manière, nous pourrons conserver notre modèle tel quel si nous décidons un jour d'utiliser une autre implémentation de JPA qu'Hibernate.

Génération base de donnée

• La couche JPA de notre programme est désormais constituée d’une entité JPA et du fichier de configuration d’Hibernate. Le but est maintenant de compléter notre projet pour pouvoir générer la base de données et tester l’enregistrement d’un premier objet.

Cette classe a pour but de créer le schéma de la base de données et d’y insérer l’Event que l’on vient de créer. Pour ce faire, on suit les étapes suivantes.

• Ouverture d’une session Hibernate à l’aide de la SessionFactory gérée dans la classe HibernateUtils : c'est cet objet qui permet de créer un pont entre l'application Java et Hibernate.

• Création d’une transaction : chaque accès à la base de données en écriture doit se faire à l'intérieur d'une transaction. L'appel à la méthode commit(), au moment de la fermeture de la transaction, permet de synchroniser la base de données et d'y effectuer les modifications nécessaires.

• Création de l'objet Event à enregistrer • Enregistrement de l'objet à l'aide de la

méthode save qu'Hibernate transformera en une opération SQL insert.

• Fermeture de la transaction et synchronisation du programme Java avec la base de données.

• Fermeture de la session : l'opération de sauvegarde est terminée, le lien avec Hibernate peut être fermé.

La manipulation

o Langage HQLo CRUDo Les associationso Relations (one-to-one)(many-to-one )(many-to-

many)o Conclusion

Découverte du langage HQL

• Découvrir HQL

• Création de la classe de tests

• Afficher et vider la table EVENTS– Vider la table EVENTS– Afficher le contenu de la table EVENTS– Test des méthodes de suppression et d'affichage

H Q L

Hibernate Query Language

C’est quoi HQL ?

• Il est aussi possible d'utiliser l'API Criteria qui va en interne exécuter une requête HQL. Le point d'entrée est d'obtenir une instance de type Criteria en invoquant la méthode createCriteria() de la session Hibernate courante : elle attend en paramètre la classe des objets attendus en résultat. L'API permet de préciser les différents critères qui seront utilisés pour générer la requête. L'API Criteria utilise HQL en sous-jacent.

• Le langage HQL est proche de SQL avec une utilisation sous forme d'objets des noms de certaines entités . C'est Hibernate qui se charge de générer la requête SQL à partir de la requête HQL en tenant compte du contexte

• Langage d'interrogation commun à toutes les bases de données

• indépendant de la base de données sous jacente : la requête SQL sera générée par Hibernate à partir du HQL en fonction de la base de données précisée via un dialect.

• les entités utilisées dans les requêtes HQL sont des objets et des propriétés. La syntaxe de HQL et ses fonctionnalités de base sont très similaire à SQL.

Le test

classe de tests prête ---> CRUD

Manipulation d'objets et opérations CRUD

o Création d'un objet

o Récupération d'un objet

o Modification d'un objet

o Suppression d'un objet

• Arrivé à ce point , 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.

Gestion des associations

• Arborescence du projet

• Configuration du projet

Structure générale Fichier de configuration

d'Hibernate Fichier HibernateUtils.java

Relation one-to-one(1--1)

• Création des entités JPA Address et Event– La classe Address– La classe Event

• Enregistrement des objets– La classe Main– Implémentation de testCreate()

• L'annotation Cascade– Définition des cascades– Ajout d'une cascade dans le projet

cascades

• Il existe différents types de Cascade en JPA, qui peuvent se cumuler. Les principales sont :– CascadeType.PERSIST pour les opérations de persistance

(méthodes persist() et save()),– CascadeType.MERGE pour les opérations de merge

(méthode merge()),– CascadeType.REMOVE pour la suppression (méthode

delete()), – CascadeType.ALL pour cumuler toutes les opérations de

Cascade.

Dans event

Relation many-to-one(1--n)

• Implémentation de l'association– Relation bidirectionnelle– Mapping de la classe User– Modifications du mapping de la classe Event

• Modifications de la classe de test– Affichage du contenu de la table USERS– Modification de l'affichage de la table EVENTS– Enregistrement de nouveaux utilisateurs– L'importance des cascades

Relation many-to-many(n--n)

• Mapping d'une relation many-to-many– La classe Guest– Ajouts dans l'entité Event

• Test du mapping– Méthode printGuests()– Méthode testCreate()

• Dans l'entité Event, ajoutons l'attribut relatif aux Items et le mapping, cette fois en @OneToMany:

Test du mapping

Conclusion