014 一对多关联映射 单向(one-to-many)

在对象模型中，一对多的关联关系，使用集合来表示。

实例场景：班级对学生；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=?