一对多关联映射(单向)

     “一对多”，顾名思义，是由“一”的一端加载“多”的一端，关系交由“一”来维护。反映在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);
    }
  }

}