在对象模型中，一对多的关联关系，使用集合来表示。
实例场景：班级对学生；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>
导出至数据库(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=? |