一对多关联映射(单向)

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

Classes.hbm.xml

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

}

本站仅提供存储服务，所有内容均由用户发布，如发现有害或侵权内容，请点击举报。