1. Association de clé primaire bidirectionnelle
L'association de clé primaire bidirectionnelle est en fait un cas particulier de l'association de clé primaire individuelle. Cependant, la configuration <One-One-One-One> doit être effectuée dans les fichiers de mappage aux deux extrémités de l'objet associé, et en outre, l'attribut d'association de clé étrangère étrangère doit être utilisé à une extrémité de la clé principale de la carte principale.
Ici, nous utilisons également la personne et la carte ID pour discuter. Une personne correspond à une carte d'identité unique, et une carte d'identité met également en œuvre unique une personne, ce qui crée une relation d'association bidirectionnelle. La clé principale de la personne est également la clé principale de IDCard, qui sont à la fois les clés principales et les clés étrangères. Cette relation d'association devient une cartographie bidirectionnelle bidirectionnelle, qui peut être exprimée dans le modèle relationnel comme indiqué ci-dessous:
Les deux tableaux de la figure utilisent l'association de clé primaire. La clé principale de la personne est la clé principale de la carte ID, afin qu'elle forme une relation de contrainte entre les clés étrangères ZHU et assure le caractère unique, la mappera dans le modèle d'objet et la transforme en une relation un à un entre la classe de personne et la classe IDCard, comme le montre la figure ci-dessous:
Cette relation individuelle a également mentionné dans l'article précédent que la balise <o-to-one> est utilisée, et ce mappage individuel est bidirectionnel, nous devons donc configurer <o à un> entre deux objets en même temps. Tout d'abord, examinons le code de classe et mappons le code de fichier correspondant à IDCard.
1. Informations correspondant à IDCard
Il existe une relation individuelle entre la classe idcard.java, la classe IDCard et la classe de personne. Par conséquent, l'attribut de personne correspondant doit être ajouté à la classe IDCard. Il s'agit d'ajouter les attributs correspondants aux clés étrangères dans le fichier de mappage et de définir la classe d'association des clés étrangères correspondante.
package com.src.hibernate; classe publique idcard {// id attribut private int id; public int getID () {return id; } public void setid (int id) {this.id = id; } // Numéro de carte Attribut Private String CardNo; String public getCardno () {return cardNo; } public void setCardno (String cardNo) {this.cardno = cardno; } // personnes correspondant au numéro de carte Personne privée; Public GetPerson () {Retour Person; } public void Setperson (personne personne) {this.person = personne; }}Le fichier de mappage idcard.hbm.xml ajoute une personne d'attribut de clé étrangère au fichier de mappage et ajoute la balise <One-to-one> correspondante. Le but est de forcer la classe des personnes contraignantes pour réaliser une relation de cartographie un à un. Enfin, définissez l'attribut contraint à True dans le mappage pour assurer la relation de contrainte forcée.
<? xml version = "1.0"?> <! Doctype Hibernate-Mapping Public "- // Hibernate / Hibernate Mapping Dtd 3.0 // en" "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"> <! - Généré 2014-5-15 23:47:00 par Hibernate. <hibernate-mapping> <class name = "com.src.hibernate.idcard" table = "idcard"> <id name = "id" type = "int" column = "personId"> <enerator> <param name = "propriété"> personne </ param> </enerator> </ id> <propriété name = "cardno" Type = "String" Column = "Cardno"> </ propriété> name = "personne" contraints = "true"> </nefo-to-un> </ class> </ hibernate-mapping>
2. Personne information correspondante
Dans la classe Person.java, en plus d'ajouter des attributs de base, la classe IDCard correspondante doit être ajoutée comme attributs, car elle est une relation d'association bidirectionnelle un à un, de sorte que la classe IDCard doit également être ajoutée à la classe de personne. La même raison est que les attributs de classe de personne sont également ajoutés à la classe IDCard.
package com.src.hibernate; classe publique Personne {// numéro d'identification privé int id; public int getID () {return id; } public void setid (int id) {this.id = id; } // Nom du nom de chaîne privée; public String getName () {Nom de retour; } public void setName (string name) {this.name = name; } // idcard privé idcard idcard; public idcard getIdCard () {return idcard; } public void setidCard (idcard idcard) {this.idcard = idcard; }}Person.hbm.xml Fichier de mappage, la stratégie de génération de clés principale dans ce fichier n'a aucune exigence particulière car elle est mutuellement limitée par la classe IDCard. Sa clé principale et sa clé étrangère sont toutes deux la clé principale de la carte ID. De plus, comme il s'agit d'une relation un à un, la balise <o-à-one> doit être ajoutée au fichier de mappage pour l'indiquer.
<? xml version = "1.0"?> <! Doctype Hibernate-Mapping Public "- // Hibernate / Hibernate Mapping Dtd 3.0 // en" "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"> <! - Généré 2014-5-15 23:47:00 par Hibernate. <hibernate-mapping> <class name = "com.src.hibernate.person" table = "personne"> <id name = "id" type = "int" colonnel = "personId"> <enerator> </ generator> </id> <propriété name = "name" type = "string" column = "PersonName"> </ propriété> <! Par défaut, il charge en fonction de la clé principale, c'est-à-dire obtient la valeur du champ de relation et charge l'objet associé en fonction de la clé principale de l'adversaire -> <un à un name = "idcard"> </nefo-to-un> </class> </ hibernate-mapping>
3. Fichier de mappage hibernate
Une fois la classe ci-dessus et le fichier de mappage configuré, les informations sur le mappage de la base de données dans hibernate.cfg.xml sont nécessaires pour ajouter deux fichiers de configuration au fichier de configuration Hibernate, afin que les éléments de génération correspondants puissent être trouvés lors de la génération de la base de données correspondante.
<? 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: //prewethost: 3306 / hibernate_one2one_pk1 </prewet> <propriété <propriété: name = "hibernate.connection.username"> root </ propriété> <propriété name = "hibernate.connection.password"> 1234 </ propriété> <propriété name = "hibernate.dialect"> org.hibernate.dialect.mysqldialect </ propriété> <mapping ressource = "com / src / hibernate / personne. <mapping ressource = "com / src / hibernate / idcard.hbm.xml"> </ mapping> </ session-factory> </ hibernate-configuration>
4. Générer des résultats
Une fois la configuration terminée, vous pouvez générer la base de données correspondante à partir du contenu ci-dessus. Dans la base de données, il générera la structure de table correspondante en fonction du contenu configuré, et il existe des touches étrangères et des champs de clés principaux correspondants dans le tableau. Lors de la génération de la structure du tableau, HiberNate sortira l'instruction SQL correspondante dans la console, comme suit:
ALTER TABLE IDCARD DROPT FORTH KEY FK806F76ABAC038CD8 TABLE DU TABLE IDCARD IDCARD TABLE SI EXISTE Personne Créer un tableau IDCard (PersonId Integer pas null, Cardno Varchar (255), Clé primaire (PersonId)) FK806F76ABAC038CD8 (PersonID), Ajouter une contrainte FK806F76ABAC038CD8 Clé étrangère (PersonID) Références Personne (PersonID)
La structure de table générée est comme indiqué sur la figure:
La clé primaire PersonID est générée dans les deux tableaux en même temps, et c'est aussi la clé étrangère correspondante. Il restreint également les clés primaires des deux tables en même temps et est unique.
5. Test d'écriture et de chargement
Après avoir généré le tableau, écrivez le tableau et lisez les données de la table, écrivez la classe de test correspondante et le test utilise des tests unitaires et écrit les méthodes de test correspondantes.
5.1 Test d'écriture
Lors de l'écriture dans la base de données, assurez-vous de noter que les deux objets écrits doivent être convertis à l'état entraînant correspondant, sinon une erreur de conversion d'état se produira. Le code de test est le suivant:
public void testsave1 () {session session = null; essayez {// créer une session d'objet de session = hibernateUtils.getSession (); // Activer Session Transaction Session.beginTransaction (); // Créer un objet de personne et sauver personne personne = new personne (); personne.setName ("Zhangsan"); session.save (personne); // Créer un objet IDCard et enregistrer idcard idcard = new idcard (); idcard.setcardno ("111111111111"); idcard.setperson (personne); session.save (idcard); // Soumettre les transactions et modifier la base de données session.getTransaction (). Commit (); } catch (exception e) {// Imprimer le message d'erreur e.printStackTrace (); // Business Rollback Session.getTransaction (). Rollback (); } Enfin {// Fermez la session HiberNateUtils.closeSession (session); }} Les données insérées sont présentées ci-dessous:
5.2 Test de chargement
Écrivez une méthode de chargement. Étant donné que la relation d'association est bidirectionnelle, l'opération de chargement correspondante doit être de charger l'autre extrémité par une extrémité, c'est-à-dire pour obtenir la classe de personne correspondante et obtenir les informations IDCard correspondantes via la classe de personne. L'inverse devrait également être vrai, le code est le suivant:
public void testload1 () {session session = null; essayez {// créer une session d'objet de session = hibernateUtils.getSession (); // Activer Session Transaction Session.beginTransaction (); // Obtenez l'objet de la personne et enregistrez personne personne = (personne) session.load (personne.class, 5); System.out.println ("idcard.id:" + personne.getIdCard (). GetID ()); System.out.println ("idcard.cardno:" + personne.getIdCard (). GetCardno ()); // Créer un objet IDCard et enregistrer idcard idcard = (idcard) session.load (idcard.class, 5); System.out.println ("Person.id:" + idcard.getSerson (). GetID ()); System.out.println ("Person.name:" + idcard.getSerson (). GetName ()); // Soumettre les transactions et modifier la base de données session.getTransaction (). Commit (); } catch (exception e) {// Imprimer le message d'erreur e.printStackTrace (); // Business Rollback Session.getTransaction (). Rollback (); } Enfin {// Fermez la session HiberNateUtils.closeSession (session); }} Exécutez la méthode de test ci-dessus et imprimez le contenu pertinent sur la console comme suit:
2. Relation de la clé étrangère bidirectionnelle
L'association bidirectionnelle des clés étrangères peut être comprise comme un cas particulier de l'association des clés étrangères. Cette spécialité est principalement parce qu'elle est une correspondance bidirectionnelle. Dans l'article précédent, il a été mentionné que si vous souhaitez ajouter un champ de clé étrangère à un tableau, vous pouvez utiliser la balise <plusieurs à un>, qui générera la colonne de clé étrangère correspondante dans le modèle de relation. Cette balise doit être utilisée si vous souhaitez réaliser une association de clé étrangère bidirectionnelle.
1. Modèle d'objet
Regardons d'abord le modèle d'objet. Les gens et les cartes d'identité sont une relation individuelle. Une personne correspond à une identité, donc les multiplexes entre eux sont un à un, et cette correspondance est à double sens. Par conséquent, son modèle d'objet est le même que la clé primaire bidirectionnelle un à un, comme indiqué dans la figure ci-dessous:
2. Modèle relationnel
Le modèle relationnel correspondant changera considérablement. La relation de clé étrangère un à un générera la clé étrangère correspondante dans un tableau. Lorsque vous obtenez la personne et la carte d'identité, cela signifie qu'il y aura une colonne de clé principale du numéro de carte d'identité dans le modèle de relation, et une situation bidirectionnelle se forme entre elle, comme indiqué sur la figure ci-dessous:
La correspondance entre eux est telle que vue dans la figure ci-dessus. Il y a la clé principale du tableau IDCard dans le tableau des personnes, formant une relation d'association de clé étrangère un à un, et c'est bidirectionnel. C'est-à-dire que la carte ID peut être obtenue par la personne, et la personne peut également être obtenue via IDCard.
Le code de l'objet Person et de l'objet IDCard est le même que le code d'objet dans l'article précédent. Il n'est pas répertorié dans le code. La seule différence est le problème de configuration du fichier de mappage.
3. Mappage de fichiers
Idcard.hbm.xml Fichier de mappage. La table IDCard n'est pas le tableau principal de la cartographie, donc lorsque vous faites un mappage individuel, vous devez utiliser la balise <o-to-one> pour la configurer, et vous devez formuler des attributs de clé étrangère dans le modèle de relation de personne. Le code spécifique est le 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"> <! -> <hibernate-mapping> <class name = "com.src.hibernate.idcard" table = "idcard"> <id name = "id" type = "int"> <générateur /> </ id> <propriété name = "cardno" type = "java.lang.string"> <colonne propriété-ref = "idcard"> </ un à un> </ class> </ hibernate-mapping>
Person.hbm.xml Fichier de mappage, le tableau des personnes est le tableau principal de la cartographie. Une colonne d'attribut de clé étrangère doit être ajoutée à la table pour indiquer la table IDCard. Par conséquent, la balise <plusieurs à un> doit être utilisée ici pour générer la clé étrangère correspondante dans l'objet personne, et unique doit également utiliser unique pour indiquer que l'attribut est unique.
<? 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.src.hibernate.person" table = "personne"> <id name = "id" type = "int" column = "personid"> <générateur /> </ id> <propriété name = "name" type = "java.lang.string"> <colonne colonnes = "idcardno" unique = "true" not-null = "true"> </suly-to-one> </ class> </ hibernate-mapping>
La configuration du fichier de mappage de l'objet est terminée, puis un modèle relationnel est généré. L'instruction SQL est la suivante:
Alter Table Person Drop Key Foreign Key FK8C768F55794A52CA TABLE DU TABLE SI EXIST TABLE DE DROPD IDCARD SI EXISTE Personne Créer la table IDCard (ID INTEGER NON NULL AUTO_INCRÉMENT, CARDNO VARCHAR (255) (PersonID)) Alter Table Person Ajouter un index FK8C768F55794A52CA (IDCARDNO), Ajouter une contrainte FK8C768F55794A52CA CLÉ FORFICALE (IDCARDNO) RÉFÉRENCES IDCARD (ID)
L'instruction SQL générée est d'abord la table créée. Lors de la création du tableau, la colonne de clé primaire est spécifiée. Une fois la création terminée, les deux tables sont modifiées pour spécifier des attributs de clé étrangère pour former une relation un à un.
Écrivez une méthode de test, adoptez des tests unitaires, chargez des objets de deux classes et obtenez un autre objet à partir d'une extrémité de l'objet respectivement
// Chargez l'objet et chargez l'objet personne à l'aide de l'objet idcard public void testload1 () {session session = null; essayez {session = hibernateutils.getSession (); session.begintransaction (); // Obtenez l'objet idcard et obtenez l'objet personne unique associé à l'objet dans idcard idcard idcard = (idcard) session.load (idcard.class, 1); System.out.println ("Person.id =" + idcard.getSerson (). GetId ()); System.out.println ("idcard.person.name =" + idcard.getSerson (). GetName ()); // objet getPerson et obtenir l'objet IDCard qui y est unique dans l'objet de la personne personne personne = (personne) session.load (personne.class, 1); System.out.println ("idcard.id:" + personne.getIdCard (). GetID ()); System.out.println ("idcard.cardno:" + personne.getIdCard (). GetCardno ()); // commit transaction session.getTransaction (). Commit (); } catch (exception e) {e.printStackTrace (); session.getTransaction (). Rollback (); } enfin {hibernateUtils.closeSession (session); }} Contenu généré:
En comparant les deux relations de cartographie, la clé primaire et les relations de cartographie des clés étrangères sont toutes deux des relations de cartographie bidirectionnelles, et la relation de cartographie doit être configurée en même temps aux deux extrémités de l'objet. La différence est que la clé primaire doit uniquement utiliser <o à un> car elle n'a pas besoin de générer des colonnes d'attribut, mais la stratégie de génération de clé principale étrangère doit être utilisée pour la clé principale du tableau et l'objet de clé étrangère est marqué; La stratégie de génération de clés étrangères doit utiliser la balise <plusieurs à un> pour générer de nouvelles colonnes de clés étrangères.
Conclusion
La cartographie individuelle dans une association bidirectionnelle a été discutée jusqu'à présent. Les deux articles discutent principalement de deux utilisations d'une association bidirectionnelle. En fait, c'est toujours très simple. N'oubliez pas d'utiliser la balise <plusieurs à un> si vous souhaitez générer une clé étrangère. S'il est unique, ajoutez l'attribut unique. La balise <One-to-one> indique uniquement une relation individuelle. Il indique seulement comment un objet charge un autre objet et n'ajoute pas de nouvelle colonne dans le modèle de relation. Le prochain article discutera des relations un-à-plusieurs.