1. Le cycle de vie de l'objet persistant
Une fois que l'application a utilisé le cadre Hibernate, les objets persistants créés par l'application passeront par un ensemble complet de cycles de vie pour terminer les opérations de base de données, parmi lesquelles les trois principaux états sont transitoires, persévérance et détachés. Les transitions de ces trois états peuvent être contrôlées dans l'application, comme le montre la figure ci-dessous:
Afin de comprendre clairement ces états, voici un exemple pour afficher les différences entre les objets de ces états. Les codes suivants aux États-Unis sont les suivants:
(1) Créez un assemblage Hibernate_Session et ajoutez un package JAR correspondant;
(2) configurer Hibernate, ajouter la classe utilisateur de l'entité correspondante et ses fichiers de mappage et configurer la connexion de la base de données correspondante;
Fichier de mappage de fichiers de classe utilisateur Code user.hbm.xml:
<? xml version = "1.0"?> <! Doctype Hibernate-Mapping public "- // Hibernate / Hibernate Mapping Dtd 3.0 // en" "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"> <! -> <hibernate-mapping> <class name = "com.hibernate.user"> <id name = "id"> <générateur /> </ id> <propriété name = "name" /> <propriété name = "mot de passe" /> <propriété name = "CreateTime" /> <propriété name = "Expiretime" /> </ class> </ HiberNate-Mapping>
Code de configuration de la connexion de la base de données Hibernate:
<? xml version = "1.0" Encoding = "UTF-8"?> <! Doctype Hibernate-Configuration Public "- // Hibernate / Hibernate Configuration DTD 3.0 // en" "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd"> <hibberne-configuration> <Session-factory> <propriété name = "hibernate.connection.driver_class"> com.mysql.jdbc.driver </ propriété> <propriété name = "hibernate.connection.url"> jdbc: mysql: // localhost: 3306 / hibernate_session </ propriété> <propriété name = "Hibernate.connection.USERNAME </ Property> <propriété Nom =" Hibernate.connection.USERNAME </ Property> <Propriété Nom = "Hibernate.connection.USERNAME" <propriété name = "hibernate.connection.password"> ab12 </ propriété> <! - Dialect: dialect, l'API sous-jacent encapsulé, similaire à l'exécution, convertit la base de données en la langue correspondante dans la configuration -> propriété name = "hibernate.dialect"> org.hibernate.dialect.mysqldialect </ property> ressource = "com / hibernate / user.hbm.xml" /> </ session-factory> </ hibernate-configuration>
(3) Ajouter une classe publique du membre statique SessionFactory pour créer un SessionFactory et son objet de session;
package com.hibernate; import org.hibernate.Session; import org.hibernate.SessionFactory; import org.hibernate.cfg.configuration; Session de classe publique {Factory de Session Static Private Session; // Déclarer la variable locale statique SessionFactory, la base de données Mirror Static {try {// Créer et obtenir le fichier de configuration pour la base de données de configuration, et obtenir HiberNate.cfg.xml Configuration CFG = new Configuration (). Configure (); factory = cfg.buildSessionFactory (); // Créez une image de base de données} catch (exception e) {e.printStackTrace (); // Message d'erreur d'impression}} Session statique publique getSession () {return factory.opencession (); // renvoie l'objet de session créé} public static sessionfactory getSessionFactory () {return factory; // Renvoie la sessionFactory correspondante} // Fermez l'objet Session Public Static void CloseSession (session session) {if (session! = Null) {if (session.isopen ()) {session.close (); }}}}}(4) Ajoutez un dossier source et ajoutez un package nommé com.hibernate dans le dossier et ajoutez un fichier de classe nommé SessionTest au package.
package com.hibernate; Importer java.util.date; Importer Junit.Framework.TestCase; import org.hibernate.Session; import org.hibernate.transaction; Classe publique SessionTest étend TestCase {} 2. Méthode de conversion d'état
1. L'objet entre directement dans l'état persistant
1.1 Obtenez la méthode
Obtenez une ligne d'informations à partir de la base de données et synchronisez les informations dans l'objet créé. Cette méthode renvoie un objet objet et renvoie NULL si aucun contenu n'est trouvé. L'exemple suivant utilise la méthode Session Get pour obtenir un objet et convertir l'objet en instance.
public void testget1 () {session session = null; Transaction tx = null; essayez {session = hibernateutils.getSession (); // Open Transaction tx = session.begintransaction (); // L'objet chargé par Get est un objet persistant // EXECUTER GET pour publier immédiatement une instruction de requête, et s'il n'existe pas, il renverra l'utilisateur nul user = (utilisateur) session.get (user.class, "FF80808145BC28CC0145BC28CE020002"); System.out.println (user.getName ()); // État persistant // Objet avec l'état persistant change lorsque les propriétés de l'objet modifient // hibernate synchroniseront user.setName ("zhao liu"); session.getTransaction (). commit (); } catch (exception e) {e.printStackTrace (); if (tx! = null) {tx.rollback (); }} enfin {hibernateUtils.closeSession (session); }} Définissez des points d'arrêt pour obtenir l'objet utilisateur.
Cet objet est obtenu et un objet utilisateur est obtenu après la coulée. La méthode setName est ajoutée au programme, ce qui signifie que le nom de la base de données sera mis à jour. Une fois l'exécution terminée, la base de données sera vérifiée, comme indiqué dans la figure ci-dessous pour mettre à jour les résultats.
1.2 Méthode de chargement
La fonction est similaire à la méthode GET, et il obtient également des données de la base de données et les synchronise dans l'objet. Cette méthode prend en charge le fonctionnement paresseux. Il renvoie un objet persistant ou un proxy, il doit donc être converti.
public void testload1 () {session session = null; essayez {session = hibernateutils.getSession (); // L'instruction de requête ne sera pas immédiatement vérifiée car la charge prend en charge paresseux (charge de retard / charge paresseuse) // Que enseigner paresseux? Ce n'est que lorsque cet objet est vraiment utilisé puis créé que l'instruction de requête sera publiée pour Hibernate. Il s'agit principalement d'améliorer les performances. Lazy est une fonctionnalité très importante dans Hibernate. Comment le paresseux de l'hibernate est-il mis en œuvre? Implémenté par des objets proxy. Les objets proxy utilisent principalement // générés par la bibliothèque CGLIB au lieu du proxy dynamique de JDK, car le proxy dynamique de JDK ne peut générer que proxy pour les classes qui implémentent les excuses. CGLIB peut générer // proxy pour les classes. Il adopte la méthode de l'héritage utilisateur utilisateur = (utilisateur) session.load (user.class, "8A1B653745BCC7B50145BCC7B7140001"); System.out.println (user.getName ()); // État persistant // objets avec un état persistant, lorsque les propriétés de l'objet modifient // hibernate synchroniseront user.setName ("zhaoliu"); session.getTransaction (). commit (); } catch (exception e) {e.printStackTrace (); } enfin {hibernateUtils.closeSession (session); }} Requête pour obtenir l'objet utilisateur comme indiqué dans la figure ci-dessous:
En analysant la figure ci-dessus, l'objet utilisateur obtenu n'est pas complet, ou il n'y a pas d'objet utilisateur commun, mais c'est un proxy. Il utilise CGLIB pour précharger l'objet et n'est vraiment créé que lors de l'utilisation de l'objet.
1.3 Get Vs Charge
Les méthodes d'obtention et de chargement sont très importantes. Ils sont souvent pris lors des entretiens avec Hibernate. Ce qui suit est une comparaison des deux suivants.
Similitudes:
(1) les fonctions sont les mêmes et les données de relation sont converties en objets;
(2) La méthode d'utilisation est la même et deux différences de paramètres sont également nécessaires:
(1) La méthode de charge prend en charge le fonctionnement paresseux, précharge l'objet et est créé uniquement lorsqu'il est utilisé. Get convertit directement les données relationnelles en objets;
(2) Si l'objet de charge de charge n'existe pas, une objetNotFoundException sera lancé et si le GET n'obtiendra pas les données, il renverra NULL.
2. Construire manuellement les objets détachés
Il existe une autre méthode pour obtenir un objet. Il est différent des méthodes de get et de chargement. Il s'agit d'une méthode manuelle. Tout d'abord, un objet est commun, puis les données de l'objet sont obtenues en formulant un ID. La méthode est la suivante:
public void Tesuer () {session session = null; essayez {session = hibernateutils.getSession (); session.begintransaction (); // Construire manuellement l'objection détachée user = new User (); user.setid ("8a1b653745bcc7b50145bcc7b7b7140001"); // État persistant // Objet avec l'état persistant, lorsque les propriétés de l'objet modifient // hibernate synchroniseront session.getTransaction (). commit () avec la base de données lors du nettoyage du cache (salet de données de données); } catch (exception e) {e.printStackTrace (); } enfin {hibernateUtils.closeSession (session); }} Afficher le schéma de résultat obtenu:
Le diagramme de résultat d'analyse est utilisé dans le code pour définir le numéro d'identification de l'objet. Une fois le numéro d'identification formulé, l'objet peut être utilisé. Une fois la transaction soumise, elle est synchronisée dans la base de données et la spécification manuelle est utilisée pour spécifier manuellement les informations de l'objet.
2.1 Supprimer la méthode
Pour supprimer l'objet spécifié dans la base de données, l'objet doit être converti à l'état persistant avant de le supprimer. Vous pouvez utiliser des méthodes Get, Charge ou Manual pour spécifier l'objet. La méthode est la suivante:
session = hibernateutils.getSession (); session.begintransaction (); User user = (User) session.load (user.class, "8A1B653745BCC6D50145BCC6D67A0001"); // Il est recommandé d'utiliser cette méthode pour supprimer, charger d'abord puis supprimer session.delete (utilisateur);
2.2 Mise à jour
Mettez à jour les données, cette méthode modifiera les données de la base de données. Lorsque vous l'utilisez, il y aura une situation dans la quantité, qui mettra à jour la valeur d'un certain champ dans la base de données ou mettra à jour toute la ligne de la base de données.
2.2.1 Mettre à jour une valeur de champ
Si vous souhaitez uniquement mettre à jour la valeur d'un certain champ, avant de mettre à jour, vous devez utiliser la charge ou obtenir pour convertir l'objet en un code d'état persistant comme suit:
// Obtenir la session d'objet de session = hibernateutils.getSession (); // Open Transaction Session.beginTransaction (); // ou vous pouvez utiliser une autre méthode pour activer //session.getTransaction (). Begin (); // Chargement pour obtenir l'objet utilisateur // Méthode 1: Utiliser la méthode de chargement // utilisateur utilisateur = (utilisateur) session.load (user.class, "8a1b653745bcc7b50145bcc7b7b7140001"); // Méthode 2: Obtenir manuellement l'utilisateur utilisateur = new user (); user.setid ("8a1b653745bcc7b50145bcc7b7b7140001"); // Mette à jour le nom user.setName ("Zhangsan"); session.update (utilisateur); session.getTransaction (). commit ();2.2.2 Mettez à jour la ligne entière <br /> Si vous souhaitez mettre à jour les données de la ligne entière, vous pouvez convertir manuellement l'état à l'état détaché et spécifier manuellement la valeur d'ID de l'objet. Le code est le suivant:
// Obtenir la session d'objet de session = hibernateutils.getSession (); // Open Transaction Session.beginTransaction (); // ou peut utiliser une autre méthode pour activer //session.getTransaction (). Begin (); // Obtenez manuellement l'utilisateur utilisateur = nouvel utilisateur (); user.setid ("8a1b653745bcc7b50145bcc7b7b7140001"); // Mette à jour le nom user.setName ("Zhangsan"); session.update (utilisateur); session.getTransaction (). commit (); Afficher les résultats de la mise à jour:
En analysant les résultats de mise à jour, il met en œuvre la ligne entière de données de la base de données. Il y a trop d'incertitudes dans cette opération de mise à jour et n'est pas recommandé de l'utiliser.
2.3 Méthode de sauvegarde
Insérer des données. Lors de l'exécution de la méthode de sauvegarde, l'instruction d'insertion de la base de données est appelée pour ajouter une nouvelle ligne à la base de données. L'objet enregistré sera converti en état persistant. Dans cet état, l'objet peut à nouveau mettre à jour l'objet et sera mis à jour dans la base de données avec des modifications lorsque la transaction est enfin soumise. comme suit:
public void testsave2 () {session session = null; Transaction tx = null; essayez {session = hibernateutils.getSession (); // Open Transaction tx = session.begintransaction (); // TRANSIGNAGE USER User = User = New User (); user.setName ("Zhangsi"); user.setpassword ("123"); user.setCreateTime (new Date ()); user.setExpiretime (new Date ()); // État persistant // Objet avec l'état persistant change lorsque les propriétés de l'objet modifient // hibernate synchroniseront session.save (utilisateur); user.setName ("Lisi"); tx.Commit (); } catch (exception e) {e.printStackTrace (); if (tx! = null) {tx.rollback (); }} enfin {hibernateutils.closeSession (session); } // Statut détaché} Afficher l'exemple précédent Run Result View:
Résultat de l'analyse: la session effectue en fait deux opérations lors de la soumission de la transaction. Combiné avec le processus de mise à jour dans le code, d'abord, un nouvel objet utilisateur est ajouté, puis une opération de sauvegarde est exécutée. Il appellera l'instruction INSERT, puis une opération SETNAME est effectuée dans le code et le nom est rénové. Cependant, il n'a pas été synchronisé dans la base de données pour le moment mais est en mémoire. À l'heure actuelle, il y aura deux États. Nous disons que les bits de données à l'heure actuelle sont des données sales, et enfin se mettre à jour vers la base de données lors de la soumission de la transaction.