一对多关联映射(单向)

“一对多”，顾名思义，是由“一”的一端加载“多”的一端，关系交由“一”来维护。反映在Java代码中就是在“一”的一端中持有“多”一端的集合，而hibernate把这种关系反映到数据库的策略是在“多”一端的表上加上一个外键指向“一”一端表。显现，其实这采用的还是“多対一”的映射原理。

     但是，在“一”一端维护关系是我们不提倡的，因为它有不可避免的缺点，即级联插入数据的时候要先插“多”一端，这样造成了两方面的不妥：1.如果我们把“多”一端的外键必须添加非空约束，将导致数据不能插入；2.即使外键不设置为非空，在插入“多”一端数据时外键将暂时为空( 因为此时它所引用的“一”记录还没有插入)，而只有等到它所引用的“一”记录插入后，再发出update语句修改外键，这样的效率必然降低。

     不管怎样，还是来看看我的Classes和Student怎么做的吧。

1.实体模型：

 

 

2.关系模型：

 

 

3.实体类：

    Student.java

public   class  Student {  
   private  Integer id;  
   private  String name;  
   //一系列的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 >  
   </ 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 >  
    <!--  配置集合属性 -->  
     < set   name ="students"   cascade ="save-update" >  
      <!--  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  {  
       /** 
        * 测试插入数据 
        */  
       /* 
        * Student student1=new Student();    
        * 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); 
        * //存储不成功.报错：org.hibernate.TransientObjectException 
        * //因为此时student对象还没有持久化,classes引用了瞬时对象student1,student2 
        * session.save(classes); 
        */  

        
        Student student1= new  Student(); student1.setName( "奇隆");  
         //session.save(student1);//先把student对象持久化 
          
        Student student2= new  Student();  
        student2.setName( "有朋");    
         //session.save(student2); 
          
        Set<Student> students= new  HashSet<Student>();  
        students.add(student1);  
        students.add(student2);  
          
        Classes classes= new  Classes();  
        classes.setName( "不一班");  
        classes.setStudents(students);  
         //存储成功.sql语句如下: 
         /* 
        Hibernate: insert into sxt_hibernate_class (name, id) values (?, ?) 
        Hibernate: insert into sxt_hibernate_student (name, id) values (?, ?) 
        Hibernate: insert into sxt_hibernate_student (name, id) values (?, ?) 
        Hibernate: update sxt_hibernate_student set class_id=? where id=? 
        Hibernate: update sxt_hibernate_student set class_id=? where id=? */  
         //可见在存储class之后,发出两个update语句,把它的两个student对象的class_id更新了. 
         //这是因为关系由"一"的一端维护(即class维护关系).这显然会降低效率. 
         //所以对于一对多,我们一般把关系交给"多"的一端维护.    
        session.save(classes);  
          
       /** 
        * 测试加载数据 
        */  
/*      Classes classes = (Classes) session.load(Classes.class, 3); 
      System.out.println(classes); 
      Set<Student> students = classes.getStudents(); 
      for (Iterator<Student> stus = students.iterator(); stus.hasNext();) { 
        System.out.println(stus.next()); 
      }*/  
      t.commit();  
    }   catch  (HibernateException e) {  
      e.printStackTrace();  
      t.rollback();  
    }   finally  {  
      HibernateUtils.closeSession(session);  
    }  
  }  

}  

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