在对象模型中，一对多的关联关系，使用集合来表示。
实例场景：班级对学生；Classes(班级)和Student(学生)之间是一对多的关系。
多对一、一对多的区别：
多对一关联映射：在多的一端加入一个外键指向一的一端，它维护的关系是多指向一的。
一对多关联映射：在多的一端加入一个外键指向一的一端，它维护的关系是一指向多的。
两者使用的策略是一样的，只是各自所站的角度不同。
Classes实体类：
|
public class Classes { private int id; private String name; //一对多通常使用Set来映射，Set是不可重复内容。 //注意使用Set这个接口，不要使用HashSet,因为hibernate有延迟加载， private Set students; public int getId() { return id; } public void setId(int id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } public String getStudents() { return students; } public void setStudents(String students) { this.students= students; } |
Students实体类：
|
public class Student { private int id; private String name; public int getId() { return id; } public void setId(int id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } } |
Student映射文件：
|
<hibernate-mapping> <class name="com.wjt276.hibernate.Student" table="t_student"> <id name="id" column="id"> <generator class="native"/> </id> <property name="name" column="name"/> </class> </hibernate-mapping> |
Classes映射文件：
|
<hibernate-mapping> <class name="com.wjt276.hibernate.Classes" table="t_classess"> <id name="id" column="id"> <generator class="native"/> </id> <property name="name" column="name"/> <!--<set>标签 映射一对多(映射set集合),name="属性集合名称"，然后在用<key>标签，在多的一端加入一个外键(column属性指定列名称)指向一的一端，再采用<one-to-many>标签说明一对多，还指定<set>标签中name="students"这个集合中的类型要使用完整的类路径(例如：class="com.wjt276.hibernate.Student") --> <set name="students"> <key column="classesid"/> <one-to-many class="com.wjt276.hibernate.Student"/> </set> </class> </hibernate-mapping> |
导出至数据库(hbmàddl)生成的SQL语句：
|
create table t_classes (id integer not null auto_increment, name varchar(255), primary key (id)) create table t_student (id integer not null auto_increment, name varchar(255), classesid integer, primary key (id)) alter table t_student add index FK4B90757070CFE27A (classesid), add constraint FK4B90757070CFE27A foreign key (classesid) references t_classes (id) |
数据库表结构如下：
一对多 单向存储实例：
|
session = HibernateUtils.getSession(); tx = session.beginTransaction(); Student student1 = new Student(); student1.setName("10"); session.save(student1);//必需先存储，否则在保存classess时出错. Student student2 = new Student(); student2.setName("祖儿"); session.save(student2);//必需先存储，否则在保存classess时出错. Set<Student> students = new HashSet<Student>(); students.add(student1); students.add(student2); Classes classes = new Classes(); classes.setName("wjt276"); classes.setStudents(students); session.save(classes); //提交事务 tx.commit(); |
生成的SQL语句：
|
Hibernate: insert into t_student (name) values (?) Hibernate: insert into t_student (name) values (?) Hibernate: insert into t_classes (name) values (?) Hibernate: update t_student set classesid=? where id=? Hibernate: update t_student set classesid=? where id=? |
一对多，在一的一端维护关系的缺点：
因为是在一的一端维护关系，这样会发出多余的更新语句，这样在批量数据时，效率不高。
还有一个，当在多的一端的那个外键设置为非空时，则在添加多的一端数据时会发生错误，数据存储不成功。
一对多 单向数据加载：
|
session = HibernateUtils.getSession(); tx = session.beginTransaction(); Classes classes = (Classes)session.load(Classes.class, 2); System.out.println("classes.name=" + classes.getName()); Set<Student> students = classes.getStudents(); for (Iterator<Student> iter = students.iterator();iter.hasNext();){ Student student = iter.next(); System.out.println(student.getName()); } //提交事务 tx.commit(); |
加载生成SQL语句：
|
Hibernate: select classes0_.id as id0_0_, classes0_.name as name0_0_ from t_classes classes0_ where classes0_.id=? Hibernate: select students0_.classesid as classesid1_, students0_.id as id1_, students0_.id as id1_0_, students0_.name as name1_0_ from t_student students0_ where students0_.classesid=? |