Java Hibernate Many-to-Many-Mapping, ausführliche Erklärung und Beispielcode

Java Hibernate Many-to-Many-Mapping

Vorwort:

1. One-Way Many-to-Many

Beispiele für One-Way Many -zu-viele verwenden Personen und Positionen. Beispielsweise kann eine Person mehrere Positionen haben und eine Position kann mehrere Personen haben. Einweg-Viele-zu-Viele bedeutet, dass nur ein Ende den Inhalt des anderen Endes abfragen und abrufen kann. Eine Viele-zu-Viele-Beziehung generiert beim Generieren des Beziehungsmodells eine Zuordnungstabelle. Die Zuordnungstabelle speichert die Primärschlüssel der beiden Beziehungstabellen. Ihre Beziehung ist wie folgt:

Codeteil:

(1) Zuordnungs- und Beziehungsklassen

Da es sich um eine einseitige Beziehung handelt, muss sie nur so sein an einem Ende verwaltet, daher müssen wir das Tag zur Konfigurationsdatei User.hbm.xml hinzufügen, die entsprechende Spaltenbeziehung zum Tag hinzufügen und das Tabellenattribut zum hinzufügen ; Tabelle, um die Generierung einer neuen Tabelle anzuzeigen, Benutzer. Der hbm.xml-Code lautet wie folgt:

<span style="font-family:KaiTi_GB2312;font-size:18px;"><hibernate-mapping>
  <class name="com.bjpowernode.hibernate.User" table="t_user">
    <id name="id">
      <generator class="native"/>
    </id>
    <property name="name"/>
    <set name="roles" table="t_user_role">
      <key column="user_id"/>
      <many-to-many class="com.bjpowernode.hibernate.Role" column="role_id" /> 
    </set>
  </class>
</hibernate-mapping></span>

Role.hbm.xml-Code relativ einfach und es ist nicht erforderlich, zusätzliche Tags hinzuzufügen, um Beziehungen aufrechtzuerhalten:

<hibernate-mapping>
  <class name="com.bjpowernode.hibernate.Role" table="t_role">
    <id name="id">
      <generator class="native"/>
    </id>
    <property name="name"/>
  </class>
</hibernate-mapping>

Da in der Benutzerzuordnung eine festgelegte Zuordnung vorhanden ist, müssen Sie diese hinzufügen Der Hashset für die entsprechende Klassendatei lautet wie folgt:

<span style="font-family:KaiTi_GB2312;font-size:18px;">import java.util.Set;
  
public class User {
    
  private int id;
    
  private String name;
  
  private Set roles;
    
  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;
  }
  
  public Set getRoles() {
    return roles;
  }
  
  public void setRoles(Set roles) {
    this.roles = roles;
  }
}</span>

Role.java-Code lautet wie folgt:

public class Role {
  
  private int id;
    
  private String name;
    
  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;
  }
}

(2) Daten hinzufügen und lesen:

Beim Hinzufügen von Daten müssen Sie zuerst die Beziehung zur Datenbank speichern und dann einen Benutzer-Hash erstellen Tabelle, fügen Sie die entsprechende Beziehung zur Hash-Tabelle hinzu, erstellen Sie schließlich einen Benutzer und fügen Sie die Hash-Tabelle dem Benutzer hinzu. In diesem Teil muss auf die Schreibreihenfolge geachtet werden, da sonst viele Nullwerte vorhanden sind, was mit der vorherigen Zuordnung identisch ist.

public void testSave1() {
    Session session = null;
    try {
      session = HibernateUtils.getSession();
      session.beginTransaction();
        
      Role r1 = new Role();
      r1.setName("数据录入人员");
      session.save(r1);
        
      Role r2 = new Role();
      r2.setName("商务主管");
      session.save(r2);
        
      Role r3 = new Role();
      r3.setName("商务经理");
      session.save(r3);
        
      Role r4 = new Role();
      r4.setName("项目会计");
      session.save(r4);
        
      User u1 = new User();
      u1.setName("张三");
      Set u1Roles = new HashSet();
      u1Roles.add(r1);
      u1Roles.add(r2);
      u1.setRoles(u1Roles);
      session.save(u1);
        
      User u2 = new User();
      u2.setName("李四");
      Set u2Roles = new HashSet();
      u2Roles.add(r1);
      u2Roles.add(r2);
      u2Roles.add(r3);
      u2.setRoles(u2Roles);
      session.save(u2);
        
      User u3 = new User();
      u3.setName("王五");
      Set u3Roles = new HashSet();
      u3Roles.add(r3);
      u3Roles.add(r4);
      u3.setRoles(u3Roles);
      session.save(u3);
        
      session.getTransaction().commit();
    }catch(Exception e) {
      e.printStackTrace();
      session.getTransaction().rollback();
    }finally {
      HibernateUtils.closeSession(session);
    }
  }

Da es sich beim Lesen um eine einseitige Beziehung handelt, müssen Sie nur den Inhalt des anderen Endes durch ein Ende lesen und lesen durch user Der Inhalt der Rolle. Der Code lautet wie folgt:

public void testLoad1() {
    Session session = null;
    try {
      session = HibernateUtils.getSession();
      session.beginTransaction();
      User user = (User)session.load(User.class, 2);
      System.out.println(user.getName());
      for (Iterator iter=user.getRoles().iterator(); iter.hasNext();) {
        Role role = (Role)iter.next();
        System.out.println(role.getName());
      }
      session.getTransaction().commit();
    }catch(Exception e) {
      e.printStackTrace();
      session.getTransaction().rollback();
    }finally {
      HibernateUtils.closeSession(session);
    }
  }

2. Bidirektionale Viele-zu-Viele-Zuordnung

Wie bereits erwähnt, hält die bidirektionale Viele-zu-Viele Beziehungen an beiden Stellen aufrecht Jedes Ende kann gleichzeitig den Inhalt des anderen Endes laden. Kommen wir also direkt zum Code:

Da es bidirektional ist, ist es notwendig, gleichzeitig eine bidirektionale Sammlungszuordnung hinzuzufügen Fügen Sie das -Tag in die Konfigurationsdatei ein und fügen Sie hinzu. Für Many-to-Many-Tags lautet der Role.hbm.xml-Code wie folgt:

<hibernate-mapping>
  <class name="com.bjpowernode.hibernate.Role" table="t_role">
    <id name="id">
      <generator class="native"/>
    </id>
    <property name="name"/>
    <set name="users" table="t_user_role">
      <key column="role_id" not-null="true"/>
      <many-to-many class="com.bjpowernode.hibernate.User" column="user_id"/>
    </set>
  </class>
</hibernate-mapping>

The Der User.hbm.xml-Code lautet wie folgt und entspricht dem unidirektionalen Zuordnungscode:

<hibernate-mapping>
  <class name="com.bjpowernode.hibernate.Role" table="t_role">
    <id name="id">
      <generator class="native"/>
    </id>
    <property name="name"/>
    <set name="users" table="t_user_role">
      <key column="role_id" not-null="true"/>
      <many-to-many class="com.bjpowernode.hibernate.User" column="user_id"/>
    </set>
  </class>
</hibernate-mapping>

Role.java-Teil, wie der unidirektionale user.java , müssen Sie einen Sammlungszuordnungssatz hinzufügen. Der Code lautet wie folgt:

import java.util.Set;
  
public class Role {
  
  private int id;
    
  private String name;
    
  private Set users;
    
  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;
  }
  
  public Set getUsers() {
    return users;
  }
  
  public void setUsers(Set users) {
    this.users = users;
  }
}

Die Codes User.hbm.xml und User.java sind die Identisch mit den Codes oben, deshalb werde ich sie hier nicht alle auflisten.

Zusammenfassung:

Durch die Einführung mehrerer Blogs glaube ich, dass jeder einseitig und mehrseitig verstanden hat. Wir müssen uns nur an einseitig und zweifach erinnern. Es ist ganz einfach.

Vielen Dank fürs Lesen, ich hoffe, es kann Ihnen helfen, vielen Dank für Ihre Unterstützung dieser Website!

Weitere Details zur Java Hibernate Many-to-Many-Zuordnung und Artikel zum Beispielcode finden Sie auf der chinesischen PHP-Website!