1. Zwei-Wege Primärschlüssel Assoziation
Die bidirektionale Primärschlüsselvereinigung ist tatsächlich ein Sonderfall von Eins-zu-Eins-Primärschlüssel-Assoziation. <Eins-zu-Eins-Konfiguration muss jedoch an beiden Enden des zugehörigen Objekts in den Zuordnungsdateien durchgeführt werden, und außerdem muss an einem Ende des Hauptschlüssels der Hauptkarte eine Attribut für fremde Schlüsselvereinigung verwendet werden.
Hier verwenden wir auch Person und IDCard, um zu diskutieren. Eine Person entspricht einer eindeutigen ID-Karte, und eine ID-Karte bildet auch eindeutig eine Person ab, so dass eine Zwei-Wege-Assoziationsbeziehung hergestellt wird. Die Hauptschlüssel der Person ist auch der Hauptschlüssel der IDCard, bei denen es sich sowohl um Primärschlüssel als auch Fremdschlüssel handelt. Diese Assoziationsbeziehung wird zu einer Zwei-Wege-Eins-zu-Eins-Zuordnung, die wie unten gezeigt im Beziehungsmodell ausgedrückt werden kann:
Die beiden Tabellen in der Abbildung verwenden Primärschlüssel -Assoziation. Der Hauptschlüssel der Person ist der Hauptschlüssel der IDCard, daher bilden sie eine Einschränkung zwischen Zhu-Fremdschlüssel und sorgen für die Einzigartigkeit, ordnen sie in das Objektmodell ein und verwandeln sie in eine Eins-zu-Eins-Beziehung zwischen der Klasse und IDCard-Klasse, wie in der folgenden Abbildung gezeigt:
Diese Eins-zu-Eins-Beziehung erwähnt auch im vorherigen Artikel, dass das <eintun und eins> Tag verwendet wird, und diese Eins-zu-Eins-Zuordnung ist bidirektional. Daher müssen wir gleichzeitig <Eins-zu-Eins-Zuordnung zwischen zwei Objekten konfigurieren. Schauen wir uns zunächst den Klassencode und den Zuordnungsdateicode an, der IDCard entspricht.
1. Informationen, die IDCard entsprechen
Es gibt eine Eins-zu-Eins-Beziehung zwischen der Klasse Idcard.java, der IDCard-Klasse und der Personklasse. Daher sollte das entsprechende Personattribut der IDCard -Klasse hinzugefügt werden. Dies soll die entsprechenden Attribute zu den Fremdschlüssel in der Zuordnungsdatei hinzufügen und die entsprechende Klassen der Fremdschlüsselvereinigung festlegen.
Paket com.src.hibernate; public class idcard {// id Attribut private int id; public int getid () {return id; } public void setId (int id) {this.id = id; } // Kartennummer Attribut Private String Cardno; public String getCardno () {return cardno; } public void setCardno (String cardno) {this.cardno = cardno; } // Personen, die der Kartennummer private Person entsprechen; public person getPerson () {return person; } public void setPerson (Person Person) {this.person = Person; }}Die IDCard.hbm.xml-Zuordnungsdatei fügt der Zuordnungsdatei eine Fremdschlüsselattributperson hinzu und fügt das entsprechende <Eins-zu-Eins-Tag hinzu. Der Zweck ist es, die Einschränkung der Personklasse zu zwingen, eine Eins-zu-Eins-Zuordnungsbeziehung zu erreichen. Setzen Sie schließlich das eingeschränkte Attribut auf True in der Zuordnung, um die erzwungene Einschränkungsbeziehung zu gewährleisten.
<? -> <hibernate-mapping> <class name = "com.src.hibernate.idcard" table = "idcard"> <id name = "id" type = "int" column = "personid"> <generator> <param name = "Eigenschaft"> person </param> </generator> </id> <one- name = "Person" Conneted = "true"> </eins zu eins> </class> </hibernate-Mapping>
2. Person entsprechende Informationen
In der Person.java-Klasse muss zusätzlich zum Hinzufügen grundlegender Attribute die entsprechende IDCard-Klasse als Attribute hinzugefügt werden, da sie eine eins-zu-Eins-Zusammenarbeit sind, sodass die IDCard-Klasse auch zur Personklasse hinzugefügt werden muss. Der gleiche Grund ist, dass die Personenklassenattribute auch zur IDCard -Klasse hinzugefügt werden.
Paket com.src.hibernate; public class Person {// id nummer private int id; public int getid () {return id; } public void setId (int id) {this.id = id; } // Name des privaten String -Namens; public String getName () {return name; } public void setName (String -Name) {this.name = name; } // IDCARD Private idCard idCard; public idCard getIdcard () {return idCard; } public void setIdCard (idCard idCard) {this.idcard = idCard; }}Person.hbm.xml Mapping -Datei, die Strategie der Primärschlüsselgenerierung in dieser Datei hat keine besonderen Anforderungen, da sie von der IDCard -Klasse gegenseitig eingeschränkt wird. Sein Hauptschlüssel und der Fremdschlüssel sind sowohl der Hauptschlüssel der IDCard. Da es sich um eine Eins-zu-Eins-Beziehung handelt, sollte das <eintunen> -T-Tag in die Zuordnungsdatei hinzugefügt werden, um dies anzuzeigen.
<? -> <hibernate-mapping> <class name = "com.src.hibernate.person" table = "person"> <id name = "id" type = "int" column = "personid"> <generator> </generator> </id> <Eigenschaft name = "name" type "string" columnname Standardmäßig lädt es nach dem Primärschlüssel, dh den Wert des Beziehungsfeldes und lädt das zugehörige Objekt gemäß der Primärschlüssel des Gegner
3. Hibernate -Mapping -Datei
Nach der Konfiguration der obigen Klassen- und Zuordnungsdatei sind die Informationen zur Datenbankzuordnung in hibernate.cfg.xml erforderlich, um der Hibernate -Konfigurationsdatei zwei Konfigurationsdateien hinzuzufügen, sodass die entsprechenden Erzeugungselemente beim Generieren der entsprechenden Datenbank gefunden werden können.
<xml Version = "1.0" coding = "utf-8"?> <! docType hibernate-configuration public "-// hibernate/hibernate configuration dtd 3.0 // en" "http://hibernate.sourceforge <ssions-factory> <Eigenschaft name = "hibernate.connection.driver_class"> com.mysql.jdbc.driver </property> <property name = "hibernate.connection.url"> jdbc: mysql: // localhost: 3306/hiebnate_one2one_pk1 <// name="hibernate.connection.username">root</property> <property name="hibernate.connection.password">1234</property> <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property> <mapping resource="com/src/hibernate/Person.hbm.xml"/> <mapping ressourcen = "com/src/hibernate/idcard.hbm.xml"> </maping> </session-factory> </hibernate-configuration>
4. Erzeugen Sie Ergebnisse
Nach Abschluss der Konfiguration können Sie die entsprechende Datenbank aus dem obigen Inhalt generieren. In der Datenbank generiert sie die entsprechende Tabellenstruktur gemäß dem konfigurierten Inhalt, und in der Tabelle befinden sich entsprechende Fremdschlüssel und Primärschlüsselfelder. Bei der Erzeugung der Tabellenstruktur gibt Hibernate die entsprechende SQL -Anweisung in der Konsole wie folgt aus:
Änderungstabelle IDCARD DROP Fremdschlüssel FK806F76ABAC038CD8 DROP -TABEL Wenn existiert IDCARD DROP -TABEL. FK806F76ABAC038CD8 (Personid), Hinzufügen von Einschränkungen FK806F76ABAC038CD8 Fremdschlüssel (Personid) Referenzen Person (Personid)
Die erzeugte Tabellenstruktur ist wie in der Abbildung dargestellt:
Der personidische Primärschlüssel wird gleichzeitig in beiden Tabellen generiert und ist auch der entsprechende Fremdschlüssel. Es schränkt auch gleichzeitig die Primärschlüssel der beiden Tabellen ein und ist einzigartig.
5. Schreiben Sie und laden Sie Test
Schreiben Sie nach dem Generieren der Tabelle die Tabelle und lesen Sie Daten aus der Tabelle, schreiben Sie die entsprechende Testklasse, und im Test verwendet Unit -Tests und schreibt die entsprechenden Testmethoden.
5.1 Test schreiben
Achten Sie beim Schreiben in die Datenbank unbedingt, dass beide geschriebenen Objekte in den entsprechenden Trainentatus umgewandelt werden müssen, da ansonsten ein Status -Conversion -Fehler auftritt. Der Testcode lautet wie folgt:
public void testsave1 () {session session = null; Versuchen Sie {// Erstellen Sie eine Sitzungsobjekt -Sitzung = hibernateUtils.getSession (); // Sitzung Transaktionssitzung aktivieren.BeginTransaction (); // Erstellen Sie ein Personenobjekt und retten Sie Person Person = new Person (); Person.SetName ("Zhangsan"); Sitzung.Save (Person); // Erstellen Sie ein IDCard -Objekt und speichern Sie idCard idcard = new idCard (); IDCARD.SETCARDNO ("11111111111111"); idcard.setperson (Person); Session.save (idCard); // Transaktionen senden und die Datenbanksitzung ändern. } catch (Ausnahme e) {// Fehlermeldung drucken e.printstacktrace (); // Business Rollback Session.getTransaction (). Rollback (); } endlich {// Schließen Sie die Sitzung hibernateUtils.closeSession (Sitzung); }} Die eingefügten Daten sind unten angezeigt:
5.2 Beladungstest
Schreiben Sie eine Lademethode. Da die Assoziationsbeziehung bidirektional ist, sollte der entsprechende Ladevorgang das andere Ende durch ein Ende laden, dh die entsprechende Klasse -Klasse und die entsprechenden IDCard -Informationen über die Personklasse erhalten. Das Gegenteil sollte auch wahr sein, der Code lautet wie folgt:
public void testload1 () {session session = null; Versuchen Sie {// Erstellen Sie eine Sitzungsobjekt -Sitzung = hibernateUtils.getSession (); // Sitzung Transaktionssitzung aktivieren.BeginTransaction (); // Holen Sie sich das Personenobjekt und speichern Sie Person Person = (Person) Sitzung.load (Person.Class, 5); System.out.println ("idcard.id:"+person.getIdcard (). GetId ()); System.out.println ("idcard.cardno:"+person.getIdcard (). GetCardno ()); // Erstellen Sie ein IDCard -Objekt und speichern Sie idCard idcard = (idCard) session.load (idcard.class, 5); System.out.println ("Person.id:"+idcard.getPerson (). GetId ()); System.out.println ("Person.name:"+idcard.getPerson (). GetName ()); // Transaktionen senden und Datenbanksitzung ändern. } catch (Ausnahme e) {// Fehlermeldung drucken e.printstacktrace (); // Business Rollback Session.getTransaction (). Rollback (); } endlich {// Schließen Sie die Sitzung hibernateUtils.closeSession (Sitzung); }} Führen Sie die obige Testmethode aus und drucken Sie die entsprechenden Inhalte auf der Konsole wie folgt aus:
2. Zwei-Wege-Auslandsschlüsselbeziehung
Die bidirektionale Association für ausländische Key kann als Sonderfall der Auslandsschlüsselvereinigung verstanden werden. Diese Spezialität liegt hauptsächlich daran, dass es sich um eine bidirektionale Korrespondenz handelt. Im vorherigen Artikel wurde erwähnt, dass Sie das <viele zu-ein> -Tag verwenden können, das die entsprechende Fremdschlüsselspalte im Beziehungsmodell generiert, wenn Sie ein fremdes Schlüsselfeld hinzufügen möchten. Dieses Tag muss verwendet werden, wenn Sie eine Zwei-Wege-Außenschlüsselvereinigung erreichen möchten.
1. Objektmodell
Schauen wir uns zunächst das Objektmodell an. Menschen und Ausweiskarten sind eine eins-zu-Eins-Beziehung. Eine Person entspricht einer Identität, sodass die Multiplexe zwischen ihnen eins zu eins sind und diese Korrespondenz zweiwegs ist. Daher ist sein Objektmodell das gleiche wie der bidirektionale Primärschlüssel eins zu eins, wie in der folgenden Abbildung gezeigt:
2. Relationales Modell
Das entsprechende Beziehungsmodell wird sich stark ändern. Die eins-zu-Eins-Fremdschlüsselbeziehung generiert den entsprechenden Fremdschlüssel in einer Tabelle. Wenn Sie die Person und die ID-Karte erhalten, bedeutet dies, dass im Beziehungsmodell eine Primärschlüsselspalte der ID-Kartennummer vorhanden ist und zwischen ihnen eine Zwei-zu-Eins-Situation gebildet wird, wie in der folgenden Abbildung gezeigt:
Die Korrespondenz zwischen ihnen ist wie in der obigen Abbildung zu sehen. Es gibt den Hauptschlüssel der IDCard-Tabelle in der Personentabelle, die eine Eins-zu-Eins-Assoziationsbeziehung aus dem Ausland bildet, und es ist bidirektional. Das heißt, die IDKard kann durch Person erhalten werden und die Person kann auch durch IDCard erhalten werden.
Der Code im Personobjekt und das IDCard -Objekt entspricht dem Objektcode im vorherigen Artikel. Es ist nicht im Code aufgeführt. Der einzige Unterschied ist das Konfigurationsproblem in der Zuordnungsdatei.
3.. Mapping -Dateien
idcard.hbm.xml Mapping -Datei. Die IDCard-Tabelle ist nicht die Haupttabelle der Zuordnung. Wenn Sie daher ein-zu-Eins-Zuordnungen durchführen, müssen Sie das <Eins-zu-Eins-Tag verwenden, um es zu konfigurieren, und Sie müssen Fremdschlüsselattribute im Personalbeziehungsmodell formulieren. Der spezifische Code lautet wie folgt:
<? 3.4.0.cr1-> <hibernate-mapping> <class name = "com.src.hibernate.idcard" table = "idcard"> <id name = "id" type = "int"> <generator /> < /id> <Eigenschaft name = "cardno" type = "java.string.string"> <columnname = "cardno" /"carnno name" = "cardno" /"carnno" = "carnno name =" cardno " /orient-one-one-a-a-name" Property-ref = "idCard"> </eins zu eins> </class> </hibernate-mapping>
Person.hbm.xml Mapping -Datei, die Personentabelle ist die Haupttabelle der Zuordnung. Die Tabelle muss eine Spalte für Fremdschlüsselattribut hinzugefügt werden, um die IDCard -Tabelle anzugeben. Daher muss hier das <viele zu eins> Tag verwendet werden, um den entsprechenden Fremdschlüssel im Personobjekt zu generieren, und eindeutig muss auch eindeutig verwendet werden, um anzuzeigen, dass das Attribut eindeutig ist.
<? 3.4.0.cr1-> <hibernate-mapping> <class name = "com.src.hibernate.person" table = "person"> <id name = "id" type = "int" column = "personid"> <generator /> < /id> <Eigenschaft name = "name" type "java.rang.string"> < /id "name" name " column = "idcardno" eindeutig = "true" not-null = "true"> </viele zu-eins> </class> </hibernate-Mapping>
Die Konfiguration der Zuordnungsdatei des Objekts ist abgeschlossen und dann wird ein relationales Modell generiert. Die SQL -Anweisung lautet wie folgt:
alter table PERSON drop foreign key FK8C768F55794A52CA drop table if exists IDCARD drop table if exists PERSON create table IDCARD (id integer not null auto_increment, CARDNO varchar(255), primary key (id)) create table PERSON (personId integer not null auto_increment, NAME varchar(255), idCardNo integer not null unique, primary key (personid)) Alter Tabelle Person Hinzufügen Index FK8C768F55794A52CA (IDCARDNO), Hinzufügen von Einschränkungen FK8C768F55794A52CA Fremd Key (IDCardno) Referenzen IDCARD (ID)
Die generierte SQL -Anweisung ist zunächst die erstellte Tabelle. Beim Erstellen der Tabelle wird die Primärschlüsselspalte angegeben. Nach Abschluss der Erstellung werden die beiden Tabellen geändert, um Fremdschlüsselattribute so anzugeben, dass sie eine Eins-zu-Eins-Beziehung bilden.
Schreiben Sie eine Testmethode, übernehmen Sie Unit -Tests, laden Sie Objekte von zwei Klassen und erhalten Sie ein anderes Objekt von einem Ende des Objekts
// Laden Sie das Objekt und laden Sie das Personobjekt mit dem IDCard -Objekt public void testload1 () {session session = null; try {session = hibernateUtils.getSession (); Sitzung.BeginTransaction (); // Erhalten Sie das IDCard -Objekt und erhalten Sie das Personobjekt, das dem Objekt in IDCard IDCard IDCARD = (IDCARD) Session.load (idCard.class, 1) eindeutig zugeordnet ist. System.out.println ("person.id ="+idcard.getPerson (). GetId ()); System.out.println ("idcard.person.name ="+idcard.getperson (). GetName ()); // GetPerson -Objekt und das IDCard -Objekt abrufen, das in der Person -Objekt -Person person = (Person) Session.load (Person.Class, 1); System.out.println ("idcard.id:"+person.getIdcard (). GetId ()); System.out.println ("idcard.cardno:"+person.getIdcard (). GetCardno ()); // eng -Transaktionssitzung.Tettransaction (). Commesent (); } catch (Ausnahme e) {e.printstacktrace (); Session.Gettransaction (). Rollback (); } endlich {HibernateUtils.Closession (Sitzung); }} Generierter Inhalt:
Wenn Sie die beiden Zuordnungsbeziehungen verglichen, sind die Beziehungen zwischen den Bidirektierungszuordnungen und der Zuordnungsbeziehung an beiden Enden des Objekts gleichzeitig konfiguriert. Der Unterschied besteht darin, dass der Primärschlüssel nur <Eins-zu-Eins-> -Rehne verwenden muss, da er keine Attributspalten generieren muss, aber die Strategie für die Fremdschlüsselgenerierung für den Primärschlüssel der Tabelle verwendet werden muss und das Fremdschlüsselobjekt gekennzeichnet ist. Die Strategie der Fremdschlüsselgenerierung muss das <viele zu eins> Tag verwenden, um neue Spalten aus fremden Schlüssel zu generieren.
Abschluss
Die Eins-zu-Eins-Kartierung in einer Zwei-Wege-Vereinigung wurde bisher diskutiert. Die beiden Artikel diskutieren hauptsächlich zwei Verwendungen einer Zwei-Wege-Vereinigung. Tatsächlich ist es immer noch sehr einfach. Denken Sie daran, das <viele zu eins> Tag zu verwenden, wenn Sie einen Fremdschlüssel generieren möchten. Wenn es eindeutig ist, fügen Sie das eindeutige Attribut hinzu. Das <Eins-zu-Eins-Tag zeigt nur eine Eins-zu-Eins-Beziehung an. Es zeigt nur an, wie ein Objekt ein anderes Objekt lädt und keine neue Spalte im Beziehungsmodell hinzufügt. In dem nächsten Artikel werden Eins-zu-Viele-Beziehungen erörtert.