Hibernate a effectué la classification et l'intégration et a constaté que Hibernate est en fait divisé en trois parties: objet central, cartographie et HQL. Ces trois parties sont les plus couramment utilisées dans le processus de développement. Les articles précédents discutent des méthodes de conversion entre les objets principaux et les objets. Ensuite, discutez des méthodes d'utilisation de la cartographie de l'hibernate.
Une fonction importante de l'hibernate est le mappage, qui peut convertir entre le modèle d'objet et le modèle relationnel. Il est préconisé par des idées de programmation orientées objet. Les développeurs qui utilisent des programmes de cartographie doivent seulement se soucier de la rédaction du code dans le modèle d'objet. Le mappage entre un objet et une base de données relationnelle est généralement défini par un document XML. Ce document de cartographie est conçu pour être lisible et peut être modifié manuellement. Je résume cette relation de cartographie comme indiqué dans la figure suivante:
Le mappage est défini via XML, géré à l'aide de la session créée par Hibernate, et enfin la session utilise JTA pour soumettre les modifications à la base de données. La session peut être comprise comme un gestionnaire de persistance, qui gère des objets dans la couche de persistance. Il est créé par SessionFactory. Lors de la programmation avec Hibernate, vous devez d'abord vous connecter à la base de données, vous devez donc d'abord vérifier la configuration de la connexion de la base de données dans le XML, créer un SessionFactory en fonction de la configuration du document (qui peut être compris comme un miroir de base de données), puis créer une SessionFactory. Enfin, la session soumettra uniformé les modifications à la base de données, qui termineront toutes les opérations.
Processus d'utilisation
1. Créez un fichier de mappage, et le fichier de mappage est suffixé avec .hbm.xml, indiquant qu'il s'agit d'un fichier de mappage Hibernate;
2. Enregistrez la classe d'entité dans le fichier de mappage et ajoutez les propriétés de la classe d'entité à la classe de mappage. Lors de l'ajout de propriétés, vous devez spécifier deux valeurs: id et propriété. L'ID indique qu'il s'agit du seul identifiant d'une entité, et la propriété indique qu'il s'agit d'une colonne de champ du tableau;
3. Soumettre des modifications et synchroniser les données.
Remarque: les développeurs qui ont développé des données XML dans la base de données comprendront bientôt que ce mappage est en fait un processus de mise à jour par lots et de création par lots, et le mappage ne fait pas exception. Hibernate stipule un ensemble de normes de cartographie qui peuvent être converties en fonction des normes. Son implémentation interne est toujours morte, il n'est donc que relativement flexible et facile à utiliser.
Un processus de cartographie de classe d'entité simple:
1. Code de propriété de la classe d'entité User1:
package com.hibernate; Importer java.util.date; classe publique User1 {ID de chaîne privée; nom de chaîne privé; mot de passe de chaîne privé; Date privée CreateTime; expiration privée; public String getID () {return id; } public String getName () {Nom de retour; } public void setName (string name) {this.name = name; } public String getPassword () {return mot de passe; } public void setPassword (String Motword) {this.password = mot de passe; } public Date getcreatetime () {return CreateTime; } public void setCreateTime (date CreateTime) {this.createtime = CreateTime; } public Date GetExpiretime () {return Expiretime; } public void setExpiretime (date Expiretime) {this.expiretime = Expiretime; }}
2. L'implémentation du code interne de user1.hbm.xml du fichier de mappage user1.java:
Les paramètres qui peuvent être définis dans la base de données de base sont également fournis dans Hibernate. Vous pouvez utiliser des attributs d'étiquette pour définir des relations de mappage spécifiques.
Classe-> Les tables utilisent des balises de classe, des propriétés couramment utilisées:
(1) Nom: Classe d'entité MAP, sa valeur doit être définie sur le nom de la classe d'entité qui doit être convertie en table. Pendant la synchronisation, la classe d'entité correspondante sera trouvée sur la base de cet attribut.
(2) Tableau: Carte le nom de la table de base de données. Si le nom de la table à mapper est différent du nom de la classe d'entité, utilisez cette propriété pour spécifier la table mappée. S'il n'existe pas, un tableau sera créé en fonction de la valeur de la propriété.
Vérifiez la structure du tableau généré par la configuration dans la figure ci-dessus, comme indiqué ci-dessous:
Le nom de la table est changé en t_user1; Le champ ID est modifié en user_id et la longueur du champ est de 32 bits; La propriété CreateEtime est mappée au champ de base de données create_time et est modifiée au type de date.
Propriété -> champs utilisent des balises d'identification ou de propriété, propriétés couramment utilisées:
(1) Nom: La fonction est similaire au nom de la balise de classe, et la valeur détermine le nom d'attribut de mappage de la classe d'entité;
(2) Colonne: similaire au tableau de la balise de classe d'entité, spécifiant le nom de colonne de la table de mappage, et sera créé s'il n'existe pas;
(3) Type: Spécifiez le type de données mappé sur les champs de la base de données et affichez le document selon les besoins;
(4) Le générateur, qui est facultatif, est utilisé pour générer un identifiant unique pour une classe persistante.
<id name = "id" type = "long" chronn = "cat_id"> <enerator> <param name = "table"> uid_table </ param> <param name = "colonne"> next_hi_value_column </ param> </ générateur> </ id>
Tous les générateurs implémentent l'interface org.hibernate.id.IdentifierGenerator. Il s'agit d'une interface très simple; Certaines applications peuvent choisir de fournir leur propre implémentation spécifique. Bien sûr, Hibernate fournit de nombreuses implémentations intégrées. Voici quelques types couramment utilisés:
(1) Identité: l'identifiant retourné est de type long, court ou int. Semblable au champ d'auto-incrémentation de la base de données.
(2) Séquence: utilisez des séquences dans DB2, PostgreSQL, Oracle, SAP DB, MCKOI et générateurs en interbase. L'identifiant retourné est de type long, court ou int. Dans toute la base de données, au lieu de s'auto-augmenter dans une seule table, vous devez spécifier que l'auto-augmentation dans une seule table doit être ajoutée.
(3) UUID: Utilisez un algorithme UUID 128 bits pour générer un identifiant de type de chaîne, qui est unique dans un réseau (en utilisant une adresse IP). L'UUID est codé comme une chaîne de numéros hexadécimaux 32 bits. Similaire au numéro de série généré par .NET.
(4) Native: Choisissez une de l'identité, de la séquence ou du HILO en fonction des capacités de la base de données sous-jacente. De manière flexible, le type d'identité utilisé sera déterminé en fonction de la base de données utilisée. MySQL sélectionnera l'identité et Oracle sélectionnera la séquence.
(5) Affectif: Créez manuellement un ID d'identification pour la classe d'entité. Il s'agit de la stratégie de génération par défaut lorsque l'élément <générateur> n'est pas spécifié.
(6) Foreign: Utilisez un autre identifiant d'objet associé. Habituellement utilisé en combinaison avec <One-to-un>.
Les développeurs sont souvent utilisés sur la méthode de configuration manuelle pour écrire des propriétés de configuration en fonction des instructions de documentation. C'est très primitif. Les débutants recommandent d'utiliser la méthode de configuration manuelle pour aider à la réflexion. Il existe également de nombreux outils tiers qui utilisent des méthodes visuelles pour configurer et générer des documents de configuration XML, ce qui améliore l'efficacité de développement. Outils similaires tels que XDoclet, Middlegen et Anormda.
Les mappages associatifs sont nombreux à un
La cartographie de base de l'hibernate est discutée ci-dessus. Une classe d'entité correspond à une table et utilise le mappage de balises <classe> dans le fichier de mappage Hibernate correspondant. Et les propriétés normales de la classe d'entité correspondent au champ de table et sont mappées à l'aide de la balise <propriété>. De plus, lors de la construction de classes d'entités, vous devez prêter attention: le constructeur par défaut sans paramètres doit être implémenté dans les classes d'entités, et une étiquette doit être fournie. Il est recommandé de ne pas utiliser Final pour modifier la classe d'entité et générer des méthodes Getter et Setter pour la classe d'entité. Enfin, plusieurs stratégies principales de génération de clés principales sont introduites et la prochaine étape consiste à discuter de la cartographie plusieurs à un.
Cette cartographie de corrélation de plusieurs à un se reflète dans le modèle d'objet. C'est une relation d'agrégation. L'utilisateur fait partie du groupe. Il y a des utilisateurs dans le groupe. Leurs cycles de vie sont différents et peuvent se refléter dans la figure suivante:
Alors, comment cette cartographie relationnelle est-elle définie en hibernate? Les éléments suivants introduiront deux méthodes: utilisez la balise <plusieurs à un> pour mapper directement, ou utilisez la cascade <plusieurs à un> pour modifier le tableau.
1. Mappage direct de plusieurs à un <Br /> Il peut être compris à partir de la signification littérale qu'elle fait référence à une relation plusieurs à un. Beaucoup se réfèrent au plus fin, et on fait référence aux moins fins. Lorsque vous l'utilisez, la balise est souvent utilisée dans le HBM de la plus fin, et l'attribut de nom de <plusieurs-à-on> est défini sur l'attribut d'une extrémité de celui dans la classe correspondante du fichier de mappage, tel que: <plusieurs à un nom = "groupe" chronique = "groupId"> </ plusieurs à un>. Cette balise est ajoutée à user.hbm.xml, qui correspond à beaucoup; La valeur du nom dans la balise est un groupe à cartographier un, et il y aura un attribut appelé groupe dans user.java. Ensuite, jetons un coup d'œil à la classe de code spécifique qui implémente l'implémentation.
(1) User.java Class Code, qui a une propriété appelée groupe, qui sera utilisée comme valeur de nom d'une extrémité de <plusieurs à un>.
classe publique User {Nom de chaîne privée; public String getName () {Nom de retour; } public void setName (string name) {this.name = name; } groupe de groupe privé; groupe public getGroup () {return groupe; } public void setGroup (groupe de groupe) {this.group = groupe; }}(2) La valeur du nom de <plusieurs à un> dans user.hbm.xml est la valeur de propriété de la seule fois dans user.java. Il générera une nouvelle colonne dans la base de données, qui peut être comprise comme une clé étrangère de la table utilisateur.
<? Xml version = "1.0"?> <! Doctype Hibernate-Mapping Public "- // Hibernate / Hibernate Mapping Dtd 3.0 // en" "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"> <! - 2014-5-14 23:39:25 -> <hibernate-mapping> <class name = "com.hibernate.user" table = "user"> <id name = "id" type = "java.lang.long"> <colonnes name = "id" /> <générateur /> </ id> <! - La valeur du nom est une propriété dans une propriété correspondante dans user.java. Il générera automatiquement une colonne dans le tableau, de sorte que la colonne est renommée à l'aide de la colonne -> <plusieurs à un name = "groupe" colonnes = "groupId"> </ plusieurs-à-on> </class> </ hibernate-mapping>
(3) Testez la relation de mappage ci-dessus, écrivez deux objets utilisateur dans le tableau, nommez l'intermédiaire de l'intermédiaire1 et user2, nommez-le Zhang San et Li SI, utilisez la session pour enregistrer l'objet, écrivez des données dans la base de données, le code est le suivant:
public void testsave1 () {session session = null; essayez {session = getSession.getSession (); session.begintransaction (); Groupe groupe = nouveau groupe (); group.setName ("Node d'alimentation"); User user1 = new User (); user1.setName ("Zhang San"); user1.setGroup (groupe); User user2 = new User (); user2.setName ("li si"); user2.setGroup (groupe); session.save (user1); session.save (user2); // L'erreur TransientObjectException sera rapportée // L'erreur se produit lors du nettoyage du cache TransientObjectexception // Parce que le groupe est un état transitoire, il n'est pas sessionné, et il n'y a pas de données correspondantes dans la base de données // Lorsque l'utilisateur est un état persistant, HiberNate ne peut pas trouver l'objet de groupe dans le cache // Ce problème a été modifié dans l'état persistant session.getTransaction (). commit (); } catch (exception e) {e.printStackTrace (); session.getTransaction (). Rollback (); } enfin {getSession.closeSession (session); }}Cependant, lors de l'utilisation du code ci-dessus, une transientObjectexception sera signalée lors de l'exécution des écritures. En effet, lors de l'enregistrement de l'objet utilisateur, il recherchera des objets de groupe en mémoire en fonction du groupe ajouté dans <plusieurs à un>. Cependant, dans le code ci-dessus, l'objet de groupe a toujours été à l'état transitoire et n'est pas géré par la session, ce qui signifie que l'objet de session ne peut pas être trouvé, et l'objet utilisateur entre dans l'état persistant, donc cette erreur sera signalée. Le code correct est le suivant:
public void testsave2 () {session session = null; essayez {session = getSession.getSession (); session.begintransaction (); Groupe groupe = nouveau groupe (); group.setName ("Node d'alimentation"); session.save (groupe); // Définissez l'objet de groupe ici sur l'objet persistant utilisateur User1 = new User (); user1.setName ("Zhang San"); user1.setGroup (groupe); User user2 = new User (); user2.setName ("li si"); user2.setGroup (groupe); session.save (user1); session.save (user2); // Les données peuvent être enregistrées correctement // parce que le groupe et l'utilisateur sont des objets à l'état persistant // L'objet associé peut être trouvé dans la session lorsque Hibernate nettoie le cache Session.getTransaction (). Commit (); } catch (exception e) {e.printStackTrace (); session.getTransaction (). Rollback (); } enfin {getSession.closeSession (session); }} 2. Cartographie en cascade
En plus de convertir à la fois l'objet de groupe et l'objet utilisateur à l'objet persistant mentionné ci-dessus, vous pouvez également utiliser les attributs de mappage Cascade Cascade, ajouter l'attribut Cascade dans l'attribut <plusieurs à un> et le copier pour sauvegarder. Vous pouvez écrire dans la base de données lorsque l'objet de groupe n'est pas à l'état persistant. De cette façon, il vous suffit de définir les attributs de groupe des deux objets utilisateur vers le même objet de groupe pour réaliser une relation de mappage plusieurs à un. À l'heure actuelle, le contenu correspondant dans user.hbm.xml est le code suivant:
<? Xml version = "1.0"?> <! Doctype Hibernate-Mapping Public "- // Hibernate / Hibernate Mapping Dtd 3.0 // en" "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"> <! - 2014-5-14 23:39:25 -> <hibernate-mapping> <class name = "com.hibernate.user" table = "user"> <id name = "id" type = "java.lang.long"> <colonned name = "id" /> <générateur /> </ id> <! - Cascade Modification Table </ class> </ hibernate-mapping>
Remarque: Une fois que Cascade est défini sur la mise à jour, il peut être en cascade de modification, d'addition et de suppression dans la base de données, mais l'opération de requête en cascade spécifique ne peut pas être effectuée.
La méthode du fichier de configuration de test correspondant est la suivante:
// Cascade Cascade public void testsave3 () {session session = null; essayez {session = getSession.getSession (); session.begintransaction (); Groupe groupe = nouveau groupe (); group.setName ("Node d'alimentation"); User user1 = new User (); user1.setName ("Zhang San"); user1.setGroup (groupe); User user2 = new User (); user2.setName ("li si"); user2.setGroup (groupe); session.save (user1); session.save (user2); // La transientObjectexception n'a pas été lancée // parce que la cascade est utilisée // Hibernate enregistre d'abord le groupe d'objets associé de l'utilisateur // le groupe et l'utilisateur sont les deux objets dans un état persistant Session.GetTransaction (). Commit (); } catch (exception e) {e.printStackTrace (); session.getTransaction (). Rollback (); } enfin {getSession.closeSession (session); }} 3. Sublimation comparative
Les deux méthodes implémentent également une méthode de mappage plusieurs à un, et les résultats sont les mêmes, mais ils sont très différents dans la mise en œuvre. Que le premier ou le deuxième type utilise <plusieurs à un> pour ajouter la balise au fichier de mappage à plusieurs extrémités, et attribuer l'attribut de nom de la balise à la valeur d'attribut de l'extrémité de la classe enregistrée par le fichier de mappage, terminant ainsi le mappage de base de plusieurs à un, ce qui est le même. La différence est que la relation de cartographie directe n'utilise pas les attributs du champ Hibernate, qui est plus flexible dans la mise en œuvre. Il prend en charge non seulement l'addition, la suppression et la modification, mais permet également la requête; La deuxième modification Cascade Cascade adopte la méthode fournie par Hibernate. Cette méthode ne prend en charge que l'ajout, la suppression et la modification et ne prend pas en charge l'interrogation.