Différences

Ci-dessous, les différences entre deux révisions de la page.

--- slam4:orm:etudiants:nicolas [2012/11/29 15:11] – jcheron
+++ slam4:orm:etudiants:nicolas [2019/08/31 14:21] (Version actuelle) – modification externe 127.0.0.1
@@ Ligne 3: / Ligne 3: @@
-  * produit -> 1 catégorie
-  * 1 catégorie -> 0,n produits
- * Ligne = détail de la commande
 ==== Création des classes métier =====
@@ Ligne 26: / Ligne 22: @@
 </code>
-==  Comment est déclaré le mapping entre un membre de la classe et un champ de la table relationnelle ? ==
+==  2) Comment est déclaré le mapping entre un membre de la classe et un champ de la table relationnelle ? ==
 Afin de déclaré un mapping entre une membre de la classe et un champ de la table relationnelle, \\
 il suffit d'ajouter une ligne de code qui permet de définir le nom de notre champ et de définir son type. \\
 voici la ligne de code qu'il vous faut : \\
-<code java h|Champ>
+<code java |hChamp>
 	@Column(name="libelle") //On indique que notre champ s'appellera Libelle
 	private String libelle; // On indique que notre champ sera un String
@@ Ligne 39: / Ligne 35: @@
 private monType monChamp
+== 3) Comment est déclarée la clé primaire de la table ? ==
+Pour déclarer une clé primaire sur Hibernate, il suffit de r'ajouter la balise "@Id" au-dessus de la colonne concerné.
+Par exemple :
+<code java |h Champ>
+	@Id // C'est cette balise qui permet de définir la clé primaire.
+	@Column(name="id")
+	private int id;
+</code>
- *3/ La clé primaire est déclarée grâce à cette ligne de code : @Id
-/ Pour déclarer une clé primaire, on a plusieurs solutions. on peut par exemple l'auto-incrementer en utilisant cette ligne de code :
+== 4) Quelles sont les possibilités de déclaration des clés primaires ? ==
+Sur hibernate, il y à plusieurs méthodes pour déclarer les clés primaires.
-@GeneratedValue(strategy=generationType.IDENTITy
+- Afin d'auto incrémenter à partir de la base donnée une clé primaire, il suffit d'utiliser cette ligne de code ;
+<code java |h Auto>
+@GeneratedValue(strategy=generationType.AUTO)
+</code>
+-
+<code java |h Identity>
+@GeneratedValue(strategy=GenerationType.IDENTITY)
+</code>
-/
+- Afin d'auto incrémenter à partir de Hibernate une clé primaire, il suffit d'utiliser cette ligne de code ;
+<code java |h Sequence>
+@GeneratedValue(strategy=GenerationType.SEQUENCE)
+</code>
+-
+<code java |h Table>
+@GeneratedValue(strategy=GenerationType.TABLE)
+</code>
+ == 5) tableau montrant la correspondance de type (entier, chaine, etc.) entre les propriétés d’une classe et les champs d’une table ==
+Voici un tableau recapitulant, la correspondance de type entre les propriétés d'une classe et les champs d'une table :
 ^Type Java^Type Sql^
 |String|Varchar|
@@ Ligne 52: / Ligne 73: @@
 |float|Float|
-/
+== 6) lien bidirectionnel entre deux classes ==
+{{:slam4:orm:etudiants:schema.jpg?800|}}
+== 7) À quoi correspond la méthode persist() ? ==
+La méthode persist sur Hibernate permet d'ajouter un élément dans la base de base de données :
+<code java |h Méthode Persist>
+Categorie aCategorie=new Categorie("Presse"); // On instancie un produit, donc l'objet que l'on insérera dans la base de donnée
+session.persist(aCategorie); // Une fois l'objet instancier, on l’insère à la BDD
+</code>
+== 8) À quoi correspond la méthode commit() ? ==
+La méthode commit permet de mettre à jour la base de donnée avec les objets persistants.
+Autrement dit, la méthode commit permet d’insérer dans la base de donnée les objets qui sont valide.
+Code de la méthode commit :
+<code java |h Méthode Commit>
+Transaction trans =  session.beginTransaction();
+trans.commit();
+</code>
+== 8) Comment ont été traduits les liens objet entre le membre categorie et produits entre ces classes dans les tables de la base ? ==
+Lors de l'insertion d'un produit et d'une catégorie dans la base de donnée, nous avions indiquer au produit qu'il fera partit de la catégorie "aCatégorie" que nous avons instancier au dessus ( Catégorie : Presse ) .
+<code java |h Produit>
+Produit aProduit=new Produit("Programmez!", 3.0f, aCategorie) //On ne passe pas l'id de la catégorie mais directement la catégorie concerné;
+</code>
+Lors de l'insertion dans la base de donnée, l'iDCategorie (clé étrangère) de notre produit à donc prit comme valeur la clé primaire de la catégorie "aCatégorie".
+== 9) Quelles requêtes SQL ont été créées par Hibernate pour réaliser la persistance ? ==
+Afin de réaliser la persistance, Hibernate à effectuer de requetes sql INSERT ;
+Ajout de la catégorie :
+<code sql |h INSERT Catégorie>
+    insert
+    into
+        Categorie
+        (libelle)
+    values
+        (?)
+</code>
+Ajout du produit :
+<code sql |h INSERT Produit>
+  insert
+    into
+        Produit
+        (idCategorie, nom, prix, id)
+    values
+        (?, ?, ?, ?)
+</code>
+== 10) Pourquoi comportent t-elles des points d'interrogation ? ==
+Les requêtes comportent des points d’interrogation car hibernate a mit en place des requêtes paramétrables.\\
+ Autrement, dit on peut utiliser la requête plusieurs-fois avec les paramètres concernés.
+Les paramètres sont dont affichés avec des "?".
+== 11)  Qu'est ce que charge exactement Hibernate lors du chargement d'un Objet ? ==
+Lors d'un chargement d'objet, Hibernate charge automatiquement tous les objets en relation avec l'objet concerné. \\
+Par exemple si l'on charge un produit, on charge aussi sa catégorie : \\
+{{:slam4:orm:etudiants:ch.png?600|}}\\
+On peut voir que la catégorie est bien chargé
+== 12) Comment sont chargés les instances liées à un objet chargé pour les liens oneToMany et manyToOne ? ==
+Pour charger les instances liées à un objet chargé pour les liens oneToMany, Hibernate charge l'objet concerné ainsi que les objets dont il est en relation.
+Par exemple, lorsque l'on charge un produit, il charge aussi sa catégorie :
+<code sql |h jj>
+    select
+        produit0_.id as id1_1_,
+        produit0_.idCategorie as idCatego4_1_1_,
+        produit0_.nom as nom1_1_,
+        produit0_.prix as prix1_1_,
+        categorie1_.id as id0_0_,
+        categorie1_.libelle as libelle0_0_
+    from
+        Produit produit0_
+    left outer join
+        Categorie categorie1_
+            on produit0_.idCategorie=categorie1_.id
+    where
+        produit0_.id=?
+</code>
+Pour charger les instances liées à un objet chargé pour les liens ManyToOne,Hibernate charge seulement l'objet concerné. Par exemple, lorsque l'on charge une catégorie, il charge seulement la catégorie et il prépare le chargement des produits.
+Hibernate:
+    select
+        categorie0_.id as id0_0_,
+        categorie0_.libelle as libelle0_0_
+    from
+        Categorie categorie0_
+    where
+        categorie0_.id=?
+Hibernate:
+    select
+        produits0_.idCategorie as idCatego4_1_,
+        produits0_.id as id1_,
+        produits0_.id as id1_0_,
+        produits0_.idCategorie as idCatego4_1_0_,
+        produits0_.nom as nom1_0_,
+        produits0_.prix as prix1_0_
+    from
+        Produit produits0_
+    where
+        produits0_.idCategorie=?
+</code>
+=== En quoi consiste le chargement paresseux d'Hibernate et la qualification lazy ? ===
+Le chargement paresseux consiste donc à charger objet par objet.\\
+Par exemple, avec l'exemple de la catégorie, il charge seulement la catégorie et non les produits, si on ne lui demande pas.