1. <?xml version="1.0"?>
2. <!DOCTYPE hibernate-mapping PUBLIC
3. "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
4. "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
5. <hibernate-mapping>
6. <class name="com.src.hibernate.Student" table="t_student">
7. <id name="id">
8. <generator class="native"/>
9. </id>
10. <property name="name"/>
11. <!-- 在多的一端Student中添加一行新的Classes列 ,并且列的名称要和Classes.hbm.xml的列明相同-->
12. <many-to-one name="classes" column="classesid"></many-to-one>
13. </class>
14. </hibernate-mapping>

1. <?xml version="1.0"?>
2. <!DOCTYPE hibernate-mapping PUBLIC
3. "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
4. "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
5. <hibernate-mapping>
6. <class name="com.src.hibernate.Classes" table="t_classes">
7. <id name="id">
8. <generator class="native"/>
9. </id>
10. <property name="name"/>
11. <set name="students" inverse="true">
12. <key column="classesid"></key>
13. <one-to-many class="com.src.hibernate.Student"></one-to-many>
14. </set>
15. </class>
16. </hibernate-mapping>

1. package com.src.hibernate;
2. public class Student {
3. //关联的班级对象
4. private Classes classes;
5. public Classes getClasses() {
6. return classes;
7. }
8. public void setClasses(Classes classes) {
9. this.classes = classes;
10. }
11. //学生id
12. private int id;
13. public int getId() {
14. return id;
15. }
16. public void setId(int id) {
17. this.id = id;
18. }
19. //学生姓名
20. private String name;
21. public String getName() {
22. return name;
23. }
24. public void setName(String name) {
25. this.name = name;
26. }
27. }

1. alter table t_student drop foreign key FK4B907570FC588BF4
2. drop table if exists t_classes
3. drop table if exists t_student
4. create table t_classes (id integer not null auto_increment, name varchar(255), primary key (id))
5. create table t_student (id integer not null auto_increment, name varchar(255), classesid integer, primary key (id))
6. alter table t_student add index FK4B907570FC588BF4 (classesid), add constraint FK4B907570FC588BF4 foreign key (classesid) references t_classes (id)

1. public void testSave(){
2. Session session=null;
3. try{
4. //创建session对象
5. session=HibernateUtils.getSession();
6. //开启事务
7. session.beginTransaction();
8. //创建班级对象，将班级对象写入到数据库中
9. Classes classes=new Classes();
10. classes.setName("class");
11. session.save(classes);
12. //创建学生1对象，将学生对象写入到数据库中
13. Student student1=new Student();
14. student1.setName("zhangsan");
15. student1.setClasses(classes);
16. session.save(student1);
17. //创建学生2对象，将学生对象写入到数据库中
18. Student student2=new Student();
19. student2.setName("lisi");
20. student2.setClasses(classes);
21. session.save(student2);
22. session.getTransaction().commit();
23. }catch(Exception e){
24. e.printStackTrace();
25. session.getTransaction().rollback();
26. }finally{
27. HibernateUtils.closeSession(session);
28. }
29. }

1. public void testSave(){
2. Session session=null;
3. try{
4. //创建session对象
5. session=HibernateUtils.getSession();
6. //开启事务
7. session.beginTransaction();
8. //创建学生1对象，将学生对象写入到数据库中
9. Student student1=new Student();
10. student1.setName("zhangsan");
11. session.save(student1);
12. //创建学生2对象，将学生对象写入到数据库中
13. Student student2=new Student();
14. student2.setName("lisi");
15. session.save(student2);
16. //创建班级对象
17. Classes classes=new Classes();
18. classes.setName("Classes");
19. //设置学生集合
20. Set students=new HashSet();
21. students.add(student1);
22. students.add(student2);
23. //将学生集合写入到Classes中
24. classes.setStudents(students);
25. //可以成功保存数据
26. //但是会发出多余的update语句来维持关系，因为是一对多的原因
27. session.save(classes);
28. session.getTransaction().commit();
29. }catch(Exception e){
30. e.printStackTrace();
31. session.getTransaction().rollback();
32. }finally{
33. HibernateUtils.closeSession(session);
34. }
35. }

     相对于写入数据而言，读取数据就变得很简单了，因为是双向的关联所以数据的读取也是双向的，可以从任何一端读取另一端的信息，如下代码：

运行上面的测试语句，生成的对应的语句信息如下：

1. Hibernate: select classes0_.id as id1_0_, classes0_.name as name1_0_ from t_classes classes0_ where classes0_.id=?
2. classes.name=class
3. Hibernate: select students0_.classesid as classesid1_, students0_.id as id1_, students0_.id as id0_0_, students0_.name as name0_0_, students0_.classesid as classesid0_0_ from t_student students0_ where students0_.classesid=?
4. student.name=lisi
5. student.name=zhangsan
6. 通过学生加载班级信息Classes.id= 1

结语

双向的一对多讨论完成，如果在使用一对多关系时建议使用双向的关联关系，它可以优化关系的类型，而且也可以保证在写入时不会出错。总结两篇文章，单向和双向性其实是通过使用<one-to-many>和<many-to-one>来实现的，前者重在设置关联关系，并不会生成新列，但是后者在生成关联关系的同时会生成新列。