1. Ein-zu-Many-Einweg-Association-Mapping
Das Objektmodell der Eins-zu-Viele-Beziehung ist oft im täglichen Leben zu sehen. Nehmen Sie Schüler und Unterricht als Beispiel. Es gibt mehrere Schüler in einer Klasse, daher ist die Beziehung zwischen der Klasse und den Schülern eine Eins-zu-Viele-Beziehung, die in das Objektmodell zugeordnet ist, wie in der folgenden Abbildung gezeigt:
Das Objektmodell zeigt, dass diese Eins-zu-Viele-Beziehung von einem Ende aufrechterhalten wird, sodass die Zuordnung in ein Beziehungsmodell mehrere Schüler unter einem Klassenbereich gibt, das eine Eins-zu-Viele-Beziehung bildet. Schülerinformationen können über die Klasse erhalten werden. Das entsprechende Beziehungsmodell lautet wie folgt:
1. Grundkonfiguration
Zeichnen Sie sie mit dem Objektmodell in den entsprechenden Beziehungscode ein. Bei der Durchführung von Beziehungs-Zuordnungen müssen Sie das <Eins-zu-Many> -Tag an einem Ende hinzufügen. Zusätzlich müssen Sie das Set -Attribut an einem Ende hinzufügen. Es unterstützt faule Laden, fügen Sie das Set-Tag in der Zuordnungsdatei hinzu und geben Sie eine Eins-zu-Viele-Beziehung an, damit Sie abfragen und das mehrfache Ende an einem Ende erreichen können.
Klassen und Zuordnungsdateien:
Es ist das wichtigste Ende des Modells. An diesem Ende müssen Sie das entsprechende Set -Attribut hinzufügen und das festgelegte Tag in der Konfigurationsdatei hinzufügen. Sie können das entsprechende <Eins-zu-Many-Objekt im SET-Tag konfigurieren. Der spezifische Klassen.java -Objektcode lautet wie folgt:
Paket com.src.hibernate; Java.util.set importieren; öffentliche Klassenklassen {private int id; public int getid () {return id; } public void setId (int id) {this.id = id; } public String getName () {return name; } public void setName (String -Name) {this.name = name; } privater Zeichenfolge Name; // Set unterstützt das faule Laden von privaten Schülern; public set getStudents () {Return Students; } public void setStudents (set student) {this.students = Studenten; }}Das SET -Attribut wird im Klassenobjekt verwendet, erklärt jedoch nur die verzögerten Ladeattribute und konfiguriert das entsprechende Objekt für das Attribut nicht. Das Objekt des Attributs muss in der Zuordnungsdatei konfiguriert werden. Sie müssen ein Set-Tag hinzufügen und das Set-Tag <Eins-zu-Many> -Tag hinzufügen. Der spezifische Code lautet wie folgt:
<? table = "t_classeses"> <id name = "id"> <generator // id> <Eigenschaft name = "name"/> <set name = "student"> <key column = "clasSID"> </key> <eintunen-many> </ein-zu-Many> </set> </class> </hiebernate-mapping>
Die Code- und Zuordnungsdateien im entsprechenden Schülerobjekt erfordern keine spezielle Konfiguration, sie müssen nur nach der üblichen Schreibmethode geschrieben werden. Die spezifische Konfigurationsmethode wird nicht ausführlich beschrieben, sondern sehr einfach. Nach der Konfiguration müssen Sie die entsprechende SQL -Anweisung generieren. Bei der Konvertierung des Objektmodells in ein relationales Modell generiert Hibernate die entsprechende Anweisung wie folgt:
ALTER TABELLE T_STUDENT DROP Fremdenschlüssel FK4B9075705E0AFEFE DROPTEL TABELLE Wenn existiert t_classes Droptabelle Wenn existiert T_Student Tabelle T_classes (ID Integer Null Null Auto_increment, Name Varchar (255), Primärschlüssel (ID)) Erstellen Sie Tabelle T_student (ID Id Intenger NICHT NOLL NOLL NOLL NOLL NOGLEGER, NAY), NAY (255), NAYSGELN (ID ID INDEGER), NICHT NOLL NOLL NOLL NOLL NOLL NOLL NOLL NULL NULL NOGOGER, NAY (255), NAYSGELN (ID ID INDEGER NICHT Integer, Primärschlüssel (ID)) Änderungstabelle T_Student Index FK4B9075705E0AFEFE (CLASSID), Einschränkung fk4b9075705e0afefe fremdschlüssel (classsid) Referenzen t_classes (id) hinzufügen
Das entsprechende erzeugte Beziehungsmodell ist unten dargestellt:
Wenn Sie SQL -Aussagen und Beziehungsmodelle verglichen, wird der Zusammenhang zwischen entsprechenden Tabellen durch Fremdschlüsseln aufrechterhalten. Erstellen Sie zunächst zwei Tabellen, geben Sie den Primärschlüssel der Tabelle an und fügen Sie schließlich eine Eins-zu-Viele-Assoziationsbeziehung für ausländische Schlüssel hinzu.
2. Grundlegende Operationen
Die Vorgänge in der Datenbank sind nichts anderes als Lesen und Schreiben, und Änderungen sind auch eine Art Schreibart. Lassen Sie uns als nächstes sehen, wie Sie Operationen in die Datenbank schreiben und lesen.
(1) Daten schreiben:
Beim Schreiben von Daten müssen Sie auf die Eins-zu-Viele-Beziehung achten, sodass Sie beim Hinzufügen mehrere Schülerklassen hinzufügen müssen. Da das entsprechende Set-Attribut den Klassen hinzugefügt wird, sollten Sie beim Hinzufügen von Studentenobjekten Hashset verwenden, damit Sie eine Eins-zu-Viele-Beziehung realisieren können. Der spezifische Code lautet wie folgt:
public void testsave2 () {session session = null; try {session = hibernateUtils.getSession (); Sitzung.BeginTransaction (); Student student1 = neuer student (); Student1.SetName ("Zhangsan"); Sitzung.Save (Student1); Student student2 = neuer student (); Student2.SetName ("Lisi"); Sitzung.Save (Student2); Klassen klassen = neue Klassen (); classes.setName ("classOne"); Setze Schüler = new Hashset (); Studenten.Add (Student1); Studenten.Add (Student2); Klassen.Setstudentents (Schüler); // Die Daten können erfolgreich gespeichert werden //, aber es wird eine zusätzliche Aktualisierungserklärung ausgestellt, um die Beziehung aufrechtzuerhalten, da es sich um eine Sitzung der Vernunft (Klassen) handelt. Session.Gettransaction (). commesent (); } catch (Ausnahme e) {e.printstacktrace (); Session.Gettransaction (). Rollback (); } endlich {HibernateUtils.Closession (Sitzung); }} Nachdem die entsprechenden Daten, die durch Ausführen des obigen Testfalls erzeugt wurden, in die Datenbank geschrieben wurden, lautet die folgende Abbildung wie folgt:
(2) Daten lesen:
Der Schreibvorgang ist relativ einfach. Sie müssen nur alle geladenen Objekte zum transienten Zustand hinzufügen und die entsprechende Methode ausführen, um den Inhalt einzufügen. Der entsprechende Lesevorgang wird jedoch etwas komplizierter sein. Da es notwendig ist zu iterieren, um alle Studentenobjekte zu erhalten, ist diese Eins-zu-Viele-Beziehung nicht sehr effizient. Der spezifische Code lautet wie folgt:
Paket com.test.hiberNate; Import Java.util.iterator; Java.util.set importieren; import com.src.hibernate.*; Import JUNIT.Framework.TestCase; import org.hibernate.session; public class One2ManyTest erweitert testCase {public void testload1 () {Session Session = null; try {session = hibernateUtils.getSession (); Sitzung.BeginTransaction (); // Klasseninformationen mit Primärschlüssel 5 Klassen Klassen = (Klassen) Sitzung (Klassen.ClASS, 5); // Klasseninformationssystem drucken // Setzen Sie den Schülersatz und laden Sie den Schüler, der über die Klassen -Set -Schüler = classs.getstudents () gesetzt ist. // die Set iterieren und die Schülerinformationen im SET für (iterator iter = student.Iterator (); iter.hasNext ();) {student student = (student) iter.next (); System.out.println ("student.name ="+student.getName ()); } Session.getTransaction (). commit (); } catch (Ausnahme e) {e.printstacktrace (); Session.Gettransaction (). Rollback (); } endlich {HibernateUtils.Closession (Sitzung); }}}Die entsprechenden Aussagen und Informationen sind wie folgt:
Hibernate: Wählen Sie classS0_.id als id1_0_, classS0_.name als name1_0_ aus t_classes classS0_ WHERE CLASSE0_.ID =? classes.name = classOne hibernate: Wählen Sie students0_.classesid als classId1_, student0_.id als id1_, student0_.id as id0_0_, student0_.name as0_0_ von t_student student0_ where student0_.classesid =? student.name = lisi student.name = zhangsan
2. Eins-zu-Viele-Bidirektional-Association-Mapping
Hier verwenden wir weiterhin Schüler und Klassen als Beispiele. Es gibt eine Eins-zu-Viele-Beziehung zwischen der Klasse und den Schülern. Es gibt mehrere Schüler in einer Klasse. Im Gegensatz zum vorherigen Artikel ist die Beziehung hier auf zwei Wege, dh ein Ende und ein Ende die Beziehung gleichzeitig beibehalten, sodass sein Objektdiagramm wie folgt lautet:
Das entsprechende Beziehungsmodelldiagramm ändert sich nicht sehr, da die Beziehung zwischen ihnen bidirektional ist, sodass beide Enden des Beziehungsmodells die Beziehung zur Beziehung gleichzeitig beibehalten und dem Beziehungsmodell wie in der folgenden Abbildung gezeigt sind:
In einer Ein-zu-Vielzahl-Einweg-Assoziation muss die Zuordnungsdatei nur an einem Ende speziell konfiguriert werden. Verwenden Sie die Konfiguration <Eins-zu-Viele> und verwenden Sie den Set-Iterator im Objektmodell, um das überarbeitete Objektmodell festzulegen. Der Unterschied besteht jedoch darin, dass in einer Zwei-Wege-Assoziation der entsprechende Auslandskey Association am anderen Ende am mehrfachen Ende hinzugefügt werden muss. Zu diesem Zeitpunkt muss die Beziehung von <viele zu eins> am mehrfachen Ende verwendet werden, um diese Bidirektionalität anzuzeigen.
1. Mapping
Klassen und Schüler werden auch hier als Beispiele verwendet. Der Inhalt der Klassen endet wie oben und ändert sich nicht, aber die Konfiguration von Schülern an den mehreren Enden ändert sich, dh das <viel-zu-Eins-Tag muss zur Zuordnungsdatei hinzugefügt werden.
Die Konfiguration von Student.hbm.xml Mapping-Datei erfordert das Hinzufügen einer Spalte für Fremdschlüssel <viele zu einem> Tag, und der Name der Spalte muss mit dem Namen der Fremdschlüsselspalte der Klassen.hbm.xml übereinstimmen. Der spezifische Code lautet wie folgt:
<? table = "t_student"> <id name = "id"> <generator/generator/> </id> <Eigenschaft name = "name"/> <!-Fügen Sie auf einer Seite eine neue Klassenspalte hinzu, und der Spaltenname sollte übereinstimmen wie die Liste der Klassen.
Die Konfiguration der Klassen.hbm.xml -Zuordnungsdatei ist die gleiche wie im vorherigen Artikel. Es ist zu beachten, dass die SET -Attributzuordnung zu der Datei classes.java hinzugefügt wird und dem Schülerobjekt entspricht. Daher muss das SET -Tag in die Zuordnungsdatei hinzugefügt werden, um anzuzeigen, dass der festgelegte Iterator im Objektmodell verwendet wird. Die spezifische Konfiguration ist wie folgt:
<? table="t_classes"> <id name="id"> <generator//id> <property name="name"/> <set name="students" inverse="true"> <key column="classesid"></key> <one-to-many></one-to-many> </set> </class> </hibernate-mapping>
2. Klasse
Die Konfiguration der Zuordnungsdatei entspricht direkt der Klasse. Mit der Zuordnungsdatei können Sie die entsprechende Klasse schreiben. Mit derselben Klasse können Sie wissen, wie Sie die entsprechende Zuordnungsdatei schreiben. Schauen wir uns an, wie Sie den entsprechenden Klassencode schreiben.
Student.Java -Klasse erfordert das Hinzufügen der zugehörigen Klassenobjektattribute zur Klasse, und Sie können beim Laden von Schülern Klassen zu verwandten Informationen erhalten.
Paket com.src.hibernate; öffentliche Klasse Student {// Assoziierte Klassenobjekt -Privatklassen Klassen; öffentliche Klassen GetClasses () {Rückgabeklassen; } public void setclasses (Klassenklassen) {this.classes = classes; } // Student ID Private int id; public int getid () {return id; } public void setId (int id) {this.id = id; } // Schülername privater Zeichenfolge Name; public String getName () {return name; } public void setName (String -Name) {this.name = name; }} Der spezifische Code -Inhalt der Datei crasses.java wird im vorherigen Artikel angezeigt und wird hier nicht ausführlich beschrieben.
Mit dem Objektmodell wird das Beziehungsmodell generiert. Die generierte SQL -Anweisung lautet wie folgt:
ALTER TABELLE T_STUDENT DROP Fremdschlüssel FK4B907570FC588BF4 DROP -Tabelle Wenn existiert t_classes Droptabelle Wenn existiert T_Student Tabelle T_classes (ID Integer nicht Null Auto_increment, Name Varcharchary), Primärschlüssel (ID)) Erstellen von TABLE T_STUDENT (ID Id Integer, nicht NULL NOLL NOUL, NAY, NAY STABEL (255) (ID -Int 2), NAYSCHLAGS, NAYSCHALS (ID Id Integer, nicht Integer, Primärschlüssel (ID)) Alter Tabelle T_Student Index FK4B907570FC588BF4 (CLASSID), Einschränkung FK4B907570FC588BF4 Fremd Key (ClassSID) Referenzen T_Classes (ID) (ID) (ID)
3. Datenbetrieb
Nachdem ich eine Tabellenstruktur erstellt hatte, schrieb ich eine Testmethode, um den Betrieb von Daten zu überprüfen. Schauen wir uns zunächst die Einführung von Daten an und fügen Sie Daten in die Tabellenstruktur ein. Es gibt zwei Situationen beim Schreiben von Daten. Eine davon besteht, zuerst ein Klassenobjekt zu erstellen, das Objekt in die Datenbank zu schreiben, dann ein Schülerobjekt zu erstellen und das Schülerobjekt dem Klassenobjekt hinzuzufügen. Das andere besteht darin, zuerst ein Schülerobjekt zu erstellen, das Schülerobjekt in die Datenbank zu schreiben und dann ein Klassenobjekt zu erstellen, um das Schülerobjekt dem Klassenobjekt hinzuzufügen. Diese beiden Arten von Operationen sind am Ende unterschiedlich, also vergleichen wir.
3.1 Schreiben Sie zuerst die Klasse und schreiben Sie dann die Schüler
Nachdem das Klassenobjekt zuerst die Klasse in die Datenbank geschrieben hat, tritt das Klassenobjekt in den transienten Status ein und verfügt über eine Zeile in der Datenbank. Schreiben Sie dann das Studentenobjekt. Das Schülerobjekt sucht nach dem entsprechenden Klassen im Primärschlüssel und schreibt es an die Tabelle. Daher sind die Daten im Beziehungsmodell nicht leer und der gespeicherte Code lautet wie folgt:
public void testsave () {session session = null; Versuchen Sie {// Sitzungsobjekt Session = hibernateUtils.getSession (); // Transaktionssitzung öffnen.BeginTransaction (); // Klassenobjekt erstellen und Klassenobjekt in die Datenbankklassen klassen = new classes (); classes.setName ("Klasse"); Sitzung.Save (Klassen); // Student 1 Objekt erstellen und ein Schülerobjekt in die Datenbank student student1 = new student () schreiben; Student1.SetName ("Zhangsan"); Student1.SetClasses (Klassen); Sitzung.Save (Student1); // Student 2 -Objekt erstellen und das Schülerobjekt in die Datenbank Student Student2 = New Student () schreiben; Student2.SetName ("Lisi"); Student2.SetClasses (Klassen); Sitzung.Save (Student2); Session.Gettransaction (). commesent (); } catch (Ausnahme e) {e.printstacktrace (); Session.Gettransaction (). Rollback (); } endlich {HibernateUtils.Closession (Sitzung); }} Die entsprechende Informationsliste in der Schreibdatenbank lautet wie folgt:
3.2 Schreiben Sie zuerst die Schüler und dann die Klasse
Schreiben Sie zuerst die Schüler in die Datenbank. Da die Schülertabelle zu diesem Zeitpunkt die wichtigsten wichtigen Informationen der entsprechenden Klassenspalte erhalten muss, aber da die Klasseninformationen in den transienten Zustand konvertiert werden, wird beim Schreiben der Schülerinformationen ein Nullwert vorliegen. Der Code ist wie folgt:
Die entsprechende Datenbankansicht nach dem Schreiben lautet wie folgt:
Wenn Sie die beiden Schreibvorgänge vergleichen, erscheinen unterschiedliche Ergebnisse, da die Reihenfolge der beiden Schreibvorgänge unterschiedlich ist, aber weil es sich um eine bidirektionale Assoziation handelt, tritt während des Schreibens keine Ausnahme auf.
4. Lesen Sie den Betrieb
Im Vergleich zum Schreiben von Daten wird das Lesen von Daten sehr einfach. Da es sich um eine bidirektionale Assoziation handelt, ist auch das Lesen von Daten bidirektional. Informationen aus dem anderen Ende können von jedem Ende gelesen werden, wie im folgenden Code gezeigt:
public void testload1 () {session session = null; try {session = hibernateUtils.getSession (); Sitzung.BeginTransaction (); // Schülerinformationen über Klassenklassen klassen = (Klassen) Sitzung.load (classes.class, 1); System.out.println ("classes.name ="+classes.getName ()); Set student = classes.getstudents (); für (iterator iter = students.iterator (); iter.hasnext ();) {student student = (student) iter.next (); System.out.println ("student.name ="+student.getName ()); } // Klasseninformationen über Schülerinformationsstudenten stu = new student (); stu = (Schüler-) Sitzung.load (Student.Class, 1); System.out.println ("Klasseninformationen über Schülerklassen laden.ID ="+stu.getClasses (). GetId ()); Session.Gettransaction (). commesent (); } catch (Ausnahme e) {e.printstacktrace (); Session.Gettransaction (). Rollback (); } endlich {HibernateUtils.Closession (Sitzung); }}Führen Sie die obige Testanweisung aus und die entsprechenden Anweisungsinformationen, die generiert wurden, lautet wie folgt:
Hibernate: Wählen Sie classS0_.id als id1_0_, classS0_.name als name1_0_ aus t_classes classS0_ WHERE CLASSE0_.ID =? classes.name = class hibernate: Wählen Sie students0_.classesid as classId1_, student0_.id as id1_, student0_.id as id0_0_, student0_.name as0_0_, student0_.classesid as class0_0_ from t_student students0_ Where0_ClasseSID =? student.name = lisi student.name = zhangsan
Ladeklasseninformationen nach Studentenklassen.id = 1