一、解析：
1、 一对多双向关联也就是说，在加载班级时，能够知道这个班级所有的学生。
同时，在加载学生时，也能够知道这个学生所在的班级。
2、我们知道，一对多关联映射和多对一关联映射是一样的，都是在多的一端加外键了。
只不过是角度不同，我们从Classes一端来看，它就是一对多，它维护了一个一指向多的关系。在加载班级时，能够把学生加载上来。返过来，多个学生是属于一个班级的，它就是多对一。
3、而像我们的用户和组，就是多对一。多对一维护了一种知道，就是多指向一，所以在加载学生时，就能拿到这个学生所在的班级。如果能够拿到它所在的班级，那么必须在对象模型Student中，持有Classes对象的一个引用。
所以要在Student实体模型中，加入一个字段classes。这样才能实现双向的一对多的关联映射。
二、新建hibernate_one2many_2项目
三、修改对象模型 ：
1、在Student.class中加上classes字段。
package com.bjsxt.hibernate;
public class Student {
private int id;
private String name;
Classesclasses;
public Classes getClasses() {
return classes;
}
public void setClasses(Classes classes) {
this.classes = classes;
}
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;
}
}
2、Classes类的内容不变
package com.bjsxt.hibernate;
import java.util.Set;
public class Classes {
private int id;
private String name;
private Set students;
public Set getStudents() {
return students;
}
public void setStudents(Set students) {
this.students = 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;
}
}
这样就实现双向了，Student类中有Class对象的引用。
同样，Classes类中有关Student对象的引用。
四、修映射文件。
1、修改改Student.hbm.xml映射文件
<?xmlversion="1.0"?>
<!DOCTYPE hibernate-mappingPUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<classname="com.bjsxt.hibernate.Student" table="t_student">
<idname="id">
<!--主键的生成方式不能是uuid。因为这种生成方式是生成32位16进制的字符串
而我们的实体类中id的类型为int.所以要修改主键的生成方式为native.就是以数字形式自增-->
<generatorclass="native"></generator>
</id>
<propertyname="name"/>
<!--因为在Student端加了一个属性，所以在Student的映射文件里面要加上这个属性的映射
它的映射就是<many-to-one>
name就是Student类中的属性名classes
如果只指定属性名，而没有指定列，就会在我们的表t_student中加入一个字段，名字是classes.
并且这个字段也指向一的一端。
可是在存储时，classes这段是不会存的。
原因是t_classes表根本不知道这个字段的存在。
因为在Classes.hbm.xml映射文件中，根本就没有看到classes这个字段的影子。
如果像我们的用户和组一样，在我们的多的一端存，那么这个字段就可以存了，因为在
多的一端，也就是Student.hbm.xml文件中，配置了它。
就如用户和组，我们new一个用户，然后new一个组，然后把这个用户设到这个组里，这样就存起来了。
但是，如果在多的一端存，则classesid字段就存不上了。因为在Student.hbm.xml文件中，
根本就没有classesid这个字段的关系。所以也就不知道classesid的存在。
所以，在映射时，映射的字段必须跟一对多那边的名字一模一样。我们在<many-to-oen>标签，用column属性来指定
所以说，在一对多双向关联映射中，在多的一端只有一个外键约束，就是跟在一的一端映射的列名相同的列名。
也就是说，从多的一端存，与在一的一端存，都会存到这个字段classesid上。
我们说，many-to-one映射会加字段，可是在一对多双向关联映射中，这个关联的字段已经有了，所以就不用再加了。
-->
<many-to-onename="classes"column="classesid"/>
</class>
</hibernate-mapping>
2、 Classes.hbm.xml映射文件不变。
<?xmlversion="1.0"?>
<!DOCTYPE hibernate-mappingPUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mappingpackage="com.bjsxt.hibernate">
<class name="Classes" table="t_classes">
<idname="id">
<generatorclass="native"></generator>
</id>
<propertyname="name"/>
<!--上面为简单属性
下面要看一下集合要如何映射
答：集合要用set标签来映射
set标签的名字属性的值就是Classes类中的集合类型数据的变量名 -->
<setname="students">
<!-- 那么要如何映射set里面的东西呢？
我们知道ont2many的映射关系，与many2one的映射是一样的，要在多的一端加字段的。
但是到目前为止，在t_student这张表里面是没有classid这个字段标识的。
所以要把这个字段加过来，加过来之后，还要做为外键指向t_classes这张表的主键
我们用key标签来实现-->
<!--在key标签里面要使用的属性是列，就是给定在t_student表中的加上的列的名字。
加了key这个标签后，就会把classid这个字段加入到t_student这张表里面了，
它做为外键指向t_class表的id字段。-->
<keycolumn="classesid"></key>
<!-- 接下来，采用one-to-many这个标签，采用这个标签，一方面是一对多，
另一方面，要用class这个属性来指定Classes.java类中的students这个集合里面
到底是什么元素。我们这个实例里面是Student对象集合。
一定要指定集合中的元素是什么类型的对象。-->
<one-to-manyclass="Student"/>
<!--ont-to-many标签就代表了students集合里面是Student对象。
这样指明之后，classes就能找到student这张表。
因为student在这里都写了。
而且在Student.hbm.xml文件中，也已经映射Student对象映射到哪张表了。
这样就可以把classid加到表t_student里面，而且做为外键指向t_classes表的主键id.-->
</set>
</class>
</hibernate-mapping>
五、数据库就不用创建了，用一对多单向关联那个数据库。
六、表也不用导出了，就用一对多单向关联那个数据库的表了。
七、测试存储
1、在多的一端存储
解析：在Student中，已经持有了Classes，并且它们之间的关系也已经配置了。
所以我们现在可以new出classes来，然后调用student的setClasses()方法，将classes设进去就可以了。
public void testSave3(){
Session session=null;
try{
session=HibernateUtils.getSession();
session.beginTransaction();
Classes classes=new Classes();
classes.setName("理想Database实验室");
//瞬时对象要保存。不然在后面的代码中，保存Student时，会因为classs在数据库中没有而发生瞬时对象不存在异常
session.save(classes);
Student student1=new Student();
student1.setName("玉儿");
//给学生分配班级
student1.setClasses(classes);
session.save(student1);
Student student2=new Student();
student2.setName("黄根儿");
student2.setClasses(classes);
session.save(student2);
session.getTransaction().commit();
}catch(Exception e){
e.printStackTrace();
session.getTransaction().rollback();
}finally{
HibernateUtils.closeSession(session);
}
}
执行后在显示SQL为：
先保存班级
insert into t_classes (name) values (?)
再存学生，因为学生知道自己是哪班的。因为先建立的班级。为什么知道？因为先建立的关系。用student1.setClasses(classes)就知道这个学生所在的班级了，给它设上了，玉儿就是理想Database实验室的。
insert into t_student (name, classesid) values (?, ?)
insert into t_student (name, classesid) values (?, ?)
八、总结：所以采用一对多关系映射时，都在多的一端来维护。
1、第七个步骤是先存班级，再存学生。那么我们像一对多单向关联映射那样，如果先存学生，再存班级，可不可以？当然还是可以的。因为Class及Classes.hbm.xml文件没有改变呀。
所以如果执行testSave2()方法：
public
void testSave2(){
Session
session=null;
try{
session=HibernateUtils.getSession();
session.beginTransaction();
//先建立学生对象集合
Studentstudent1=new
Student();
student1.setName("菜10");
session.save(student1);
Studentstudent2=new
Student();
student2.setName("容祖儿");
session.save(student2);
//用泛型了
//因为班级里的学生是一个集合，所以要构造一个集合出来
Set<Student> students=newHashSet<Student>();
//向集合里面加数据
students.add(student1);
students.add(student2);
//要知道哪个学生所在的班级，要new班级出来
Classesclasses=new
Classes();
classes.setName("尚学堂");
//这个班级里面有哪些学生，要用set方法加上去。
//这样这个尚学堂班级里面就有两个学生了
classes.setStudents(students);
session.save(classes);
session.getTransaction().commit();
}catch(Exception
e){
e.printStackTrace();
session.getTransaction().rollback();
}finally{
HibernateUtils.closeSession(session);
}
}
执行后，数据也可保存上去。数据库中显示存入后的数据
mysql>
select * from t_classes;
+----+--------------------+
| id
|name |
+----+--------------------+
| 1
|尚学堂 |
| 2 | 理想Database实验室 |
| 3
|尚学堂 |
+----+--------------------+
3 rows in
set (0.00 sec)
mysql>
select * from t_student;
+----+--------+-----------+
| id |
name | classesid
|
+----+--------+-----------+
| 1 |
菜10 | 1 |
| 2 |
容祖儿| 1 |
| 3 |
玉儿 | 2 |
| 4 |
黄根儿| 2 |
| 5 |
菜10 | 3 |
| 6 |
容祖儿| 3 |
+----+--------+-----------+
6 rows in
set (0.00 sec)
2、所以如果想让多的一端来维护，那么原本由一的一端来维护的，要让一的一端来维护的失消。
在Classes.hbm.xml文件中，默认反转为false。就是可以在一的一端来维护的。在此<setname=”students” inverse=”true”>
就是在set标签中设置反转为true。就是反转了，反给别人了，使一的一端失效。
3、这样设置完之后，如果再执行testSave2()，就是先存学生，此时学生的classesid字段的值为空。然后再存班级，然后由班级更新学生的classesid字段。这种反转是关系的反转。
执行后，在控制台产生三条insert语句，如下：
insert into t_student (name,classesid) value(?,?)当存学生时，classesid字段值肯定为null.
insert into t_student (name,classesid) value(?,?)
insert into t_classes (name) value(?)
也就是说，t_classes表没有发出update语句来更新t_student表的classesid字段的值。因为我们已经设置为反转了，不让一的一端来维护关系了，一的一端就不管了，所以update语句就不发了。虽然可以保存，但是在一的一端来维护的关系失效了，也就是说，班级根本不知道有学生存在。
MYSqL数据库显示如下：
mysql> select * from t_classes;
+----+--------------------+
| id |name |
+----+--------------------+
| 1 |尚学堂 |
| 2 | 理想Database实验室 |
| 3 |尚学堂 |
| 4 |尚学堂 |
+----+--------------------+
5 rows in set (0.00 sec)
mysql> select * from t_student;
+----+--------+-----------+
| id | name | classesid|
+----+--------+-----------+
| 1 | 菜10 | 1 |
| 2 | 容祖儿| 1 |
| 3 | 玉儿 | 2|
| 4 | 黄根儿| 2 |
| 5 | 菜10 | 3 |
| 6 | 容祖儿| 3 |
| 7 | 菜10 | NULL |
| 8 | 容祖儿| NULL |
+----+--------+-----------+
也就是说，执行结果如下：数据可以正常保存，但是关系字段为null.
九、所以当一的一端将关系设置为反转后，只能在多的一端来维护。
就是说，先new出classes，然后将其分配到学生里面。
在多的一端维护的好处是，不用发出update。因为学生知道自己是哪个班级的了。
而且，为什么在多的一端维护关系比较好？因为关系字段就在多的一端，就在student这个表里。当然谁离的近，谁维护好了。
十、readme. txt
hibernate 一对多关联映射双向。（双向关联Classed<----->Student)
一对多双向关联映射：
*在一一端的集合上使用<key>，在对方表中加入一个外键指向一一端
*在多一端采用<many-to-one>
注意：<key>标签指定的外键字段必须和<many-to-one>指定的外键字段一致，否则引用字段的错误
如果在“一”一端维护一对多关系， hibernate会发出多余的update语句，所以我们一般在多的一端来维护关联关系
关于invserse属性：
inverse主要用在一对多和多对多双向关联上，inverse可以被设置到集合标签<set> 上，
默认inverse为false，所以我们可以从“一”一端和“多”一端维护关联关系。
如果设置成inverse为true,则我们只能从多一端来维护关联关系
注意：inverse属性，只影响数据的存储，也就是持久化
inverse和cascade
*inverse是关联关系的控制方向
*cascade操作上的连锁反应
十一
测试加载：加载学生，看一下能不能把学生对应的班级加载上来。
testLoad3()测试方法如下：
public
void testLoad3(){
Session
session=null;
try{
session=HibernateUtils.getSession();
Studentstudent=(Student)session.load(Student.class,4);
System.out.println(student.getName());
System.out.println(student.getClasses().getName());
session.beginTransaction();
session.getTransaction().commit();
}catch(Exception
e){
e.printStackTrace();
session.getTransaction().rollback();
}finally{
HibernateUtils.closeSession(session);
}
}
生成的SQL语句：
select student0_.id as id1_0_, student0_.name as name1_0_,student0_.classesid as classesid1_0_ from t_student student0_ wherestudent0_.id=?
select classes0_.id as id0_0_, classes0_.name as name0_0_ fromt_classes classes0_ where classes0_.id=?
输出的数据：
黄根儿
理想Database实验室