一对多关联映射(双向)

一对多双向，从实体类上讲究是在“多”的一端持有“一”的实例，并在配置文件中用<many-to-one>标签将其配置上。这里有一点要特别注意，当两边都能够维护关系的时候，推荐让“多”的一端来做，做法上就是在“一”一端映射文件的<set>标签中设置属性inverse="true"。另外，<key>中为“多”一端表设置的外键要和<many-to-one>中设置的外键要一样。

1.实体模型：

 

2.关系模型：

 

3.实体类：

   Student.java

public   class  Student {  
   private  Integer id;  
   private  String name;  
   private  Classes classes;  
   //一系列的 setter.getter方法 
  @Override  
   public  String toString() {  
     return   "name of student: "  + name;  
  }  
}

   Classes.java

public   class  Classes {  
   private  Integer id;  
   private  String name;  
   private  Set<Student> students;  
   //一系列的setter.getter方法 
  @Override  
   public  String toString() {  
     return   "name of class: "  + name;  
  }  
}

 

4.映射文件：

   Student.hbm.xml

   < class   name ="com.sxt.hibernate.one2many.entity.Student"   table ="sxt_hibernate_student" >  
     < id   name ="id"   length ="4" >  
       < generator   class ="native" > </ generator >  
     </ id >  
     < property   name ="name"   length ="10" > </ property >  
    <!--  此处column指定的外键要和对方key中指定的外键一致 -->  
     < many-to-one   name ="classes"   column ="class_id"   cascade ="save-update" > </ many-to-one >  
   </ class >

    Classes.hbm.xml

   < class   name ="com.sxt.hibernate.one2many.entity.Classes"   table ="sxt_hibernate_class" >  
     < id   name ="id"   length ="4" >  
       < generator   class ="native" > </ generator >  
     </ id >  
     < property   name ="name"   length ="10" > </ property >  
    <!--  配置集合属性 -->  
    <!-- inverse="true"含义,把关联关系交由对方一端维护,而在操作本方数据时不再维护关系.    -->  
     < set   name ="students"   cascade ="save-update"   inverse ="true" >  
      <!--  key的含义,指在另一端增加的外键指向本主键. 
        如果设置上属性not-null="true",表示该外键非空,则在由"一"的一端维护关系时, 
        可能导致插入数据异常PropertyValueException. 
        -->  
       < key   column ="class_id" > </ key >  
      <!-- one-to-many含义,指出set集合中的元素类型,以供加载时使用    -->  
       < one-to-many   class ="com.sxt.hibernate.one2many.entity.Student" />  
     </ set >  
   </ class >

 

5.hibernate配置文件：

   参见上一篇。

 

6.测试方法：

   public   static   void  main(String[] args) {  
    Session session = HibernateUtils.getSession();  
    Transaction t = session.beginTransaction();  
     try  {  
       /** 
        * 测试插入数据 
        */  
/*      Classes classes = new Classes();//情况1:从"多"的一端保存(这完全就是个多对一的情况) 
      classes.setName("不一班"); 
        
      Student student1 = new Student(); 
      student1.setName("志朋"); 
      student1.setClasses(classes); 
      //存储成功.sql语句如下: 
      //Hibernate: insert into sxt_hibernate_class (name, id) values (?, ?) 
      //Hibernate: insert into sxt_hibernate_student (name, class_id, id) values (?, ?, ?) 
      //Hibernate: insert into sxt_hibernate_student (name, class_id, id) values (?, ?, ?) 
      //为了不至于出现TransientObjectException,应先保存classes对象或者在<many-to-one>中 
         //加上cascade="save-update,all" 
      session.save(student1); 

      Student student2 = new Student(); 
      student2.setName("有朋"); 
      student2.setClasses(classes); 
      //由于此时classes已经是持久化对象了,所以此处不会再存储一遍classes了 
      session.save(student2); 
*/  
/*      Student student1=new Student();//情况2:从"一"的一端保存 
      student1.setName("志鹏"); 
        
      Student student2=new Student(); 
      student2.setName("有朋"); 
        
      Set<Student> students=new HashSet<Student>(); 
      students.add(student1); 
      students.add(student2); 
        
      Classes classes=new Classes(); 
      classes.setName("不一班"); 
      classes.setStudents(students); 
      //也能正确保存.sql语句如下： 
      //如果<set>标签中没有inverse="true":(情况2.1) 
      //Hibernate: insert into sxt_hibernate_class (name, id) values (?, ?) 
      //Hibernate: insert into sxt_hibernate_student (name, class_id, id) values (?, ?, ?) 
      //Hibernate: insert into sxt_hibernate_student (name, class_id, id) values (?, ?, ?) 
      //Hibernate: update sxt_hibernate_student set class_id=? where id=? 
      //Hibernate: update sxt_hibernate_student set class_id=? where id=? 
      //存储过程是这样的:存classes时,由于有cascade="save-update",它会先触发存储student, 
      //由于默认inverse=false,student不负责维护关系,所以此时它的class_id为空;然后回来存储classes,而此时 
      //classes不得不来维护关系(发出update语句修改student的外键). 
         
      //如果<set>标签中有inverse="true":(情况2.2) 
      //Hibernate: insert into sxt_hibernate_class (name, id) values (?, ?) 
      //Hibernate: insert into sxt_hibernate_student (name, class_id, id) values (?, ?, ?) 
      //Hibernate: insert into sxt_hibernate_student (name, class_id, id) values (?, ?, ?) 
      //但是插入的student记录class_id字段为空,因为"一"一端不再负责维护关系了. 
      //存储过程是这样的:存classes时,由于有cascade="save-update",它会先触发存储student;    
      // 而在存储student时,虽然inverse="true"指明了由它来维护关联关系,所以他要先存主表class, 
      // 再回来存副表student,但是student发现它的classes为null,就把class_id字段设为了空. 
        
         
      session.save(classes); 
*/        
/*      Classes classes=new Classes();//情况3 
      classes.setName("不一班"); 
        
      Student student1=new Student(); 
      student1.setName("志鹏"); 
      student1.setClasses(classes); 
        
      Student student2=new Student(); 
      student2.setName("有朋"); 
      student2.setClasses(classes); 
        
      Set<Student> students=new HashSet<Student>(); 
      students.add(student1); 
      students.add(student2); 
        
      classes.setStudents(students); 
      //同样能正确保存.sql语句如下: 
      //如果<set>标签中有inverse="true",cascade="save-update": 
      //Hibernate: insert into sxt_hibernate_class (name, id) values (?, ?) 
      //Hibernate: insert into sxt_hibernate_student (name, class_id, id) values (?, ?, ?) 
      //Hibernate: insert into sxt_hibernate_student (name, class_id, id) values (?, ?, ?) 
      //这种情况student的class_id也有了,因为在插入student时,由student来维护了关系,而它引用的class已经是持久化的了. 
         
      //存储过程是这样的:存classes时,由于有cascade="save-update",它会先触发存储student;    
      // 而在存储student时,inverse="true"指明了由它来维护关联关系,所以他要先存主表class,再回来存副表student 
      session.save(classes);*/  
       /** 
        * 小结:情况1是我们提倡的; 
        *         情况2.1虽然也能实现正确插入,但是效率低; 
        *         情况2.2显然是错误的; 
        *         情况3虽然也能实现,并且效率也不低,但是编程上比较麻烦. 
        */  
        
       /** 
        * 测试加载数据 
        */  
      Student student=(Student)session.get(Student. class, 3);  
      System.out.println(student);  
      System.out.println(student.getClasses());  
      t.commit();  
    }   catch  (HibernateException e) {  
      e.printStackTrace();  
      t.rollback();  
    }   finally  {  
      HibernateUtils.closeSession(session);  
    }  
  }  
}

本文出自 “夜狼” 博客，请务必保留此出处http://yangfei520.blog.51cto.com/1041581/275947