java 双向映射_一对多关联映射(双向)

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对象或者在中

//加上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 students=new HashSet();

students.add(student1);

students.add(student2);

Classes classes=new Classes();

classes.setName("不一班");

classes.setStudents(students);

//也能正确保存.sql语句如下：

//如果标签中没有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的外键).

//如果标签中有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 students=new HashSet();

students.add(student1);

students.add(student2);

classes.setStudents(students);

//同样能正确保存.sql语句如下:

//如果标签中有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);

}

}

}