java Hibernate mappage plusieurs-à-plusieurs explication détaillée et exemple de code

Mappage plusieurs-à-plusieurs Java Hibernate

Avant-propos :

1. -to-many utilise des personnes et des postes. Par exemple, une personne peut occuper plusieurs postes, et un poste peut avoir plusieurs personnes. Un sens plusieurs à plusieurs signifie qu'une seule extrémité peut interroger et obtenir le contenu de l'autre extrémité. Une relation plusieurs-à-plusieurs générera une table d'association avant l'objet lors de la génération du modèle de relation. La table d'association stocke les clés primaires des deux tables de relations :

<.>

Partie code :

(1) Cartographie et classes de relations

Parce qu'il s'agit d'une relation à sens unique, il suffit qu'elle soit maintenu à une extrémité, vous devez donc ajouter la balise f28ba8748e989755003e512f5a4f884c au fichier de configuration User.hbm.xml, ajouter la relation de colonne correspondante à la balise et ajouter l'attribut de table au ace372f96ca3ec664acb3aaa2421b04c ; table pour indiquer la génération d'une nouvelle table, Utilisateur Le code hbm.xml est le suivant :

<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>

Le code Role.hbm.xml est relativement simple et il n'est pas nécessaire d'ajouter des balises supplémentaires pour maintenir les relations :

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

Comme il y a un mappage défini dans le mappage utilisateur, vous devez ajouter Hashset vers le fichier de classe correspondant. Le code User.java est le suivant :

<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>

Le code Role.java est le suivant :

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) Ajouter et lire des données :

Lors de l'ajout de données, vous devez d'abord enregistrer la relation avec la base de données, puis créer un hachage utilisateur table, ajoutez la relation correspondante dans la table de hachage, et enfin créez un utilisateur et ajoutez la table de hachage à l'utilisateur. Ce à quoi il faut prêter attention dans cette partie, c'est l'ordre d'écriture, sinon il y aura de nombreuses valeurs nulles, ce qui est le même que le mappage précédent.

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);
    }
  }

Parce qu'il s'agit d'une relation à sens unique lors de la lecture, il vous suffit de lire le contenu de l'autre extrémité à travers l'une et de lire via user Le contenu du rôle. Le code est le suivant :

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. Mappage plusieurs-à-plusieurs bidirectionnel

Comme introduit précédemment, le plusieurs-à-plusieurs bidirectionnel entretient des relations aux deux se termine en même temps. Chaque extrémité peut charger le contenu de l'autre extrémité. Sans plus tarder, passons directement au code :

Parce qu'il est bidirectionnel, il est nécessaire d'ajouter en même temps un mappage de collection bidirectionnel. Ajoutez la balise ace372f96ca3ec664acb3aaa2421b04c dans le fichier de configuration et ajoutez Pour plusieurs balises, le code Role.hbm.xml est le suivant :

<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>

Le Le code User.hbm.xml est le suivant, qui est le même que le code de mappage unidirectionnel :

<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>

Partie Role.java, comme la partie user.java unidirectionnelle , vous devez ajouter un jeu de mapping de collection, le code est le suivant :

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;
  }
}

Les codes User.hbm.xml et User.java sont les identiques aux codes ci-dessus, donc je ne les mettrai pas tous ici.

Résumé :

Grâce à l'introduction de plusieurs blogs, je crois que tout le monde a compris le sens unique et le sens multiple. Il suffit de se souvenir du sens unique et du sens double. C'est assez simple.

Merci d'avoir lu, j'espère que cela pourra vous aider, merci pour votre soutien à ce site !

Pour plus de détails sur le mappage plusieurs-à-plusieurs Java Hibernate et des exemples d'articles liés au code, veuillez prêter attention au site Web PHP chinois !