JAVAWEB开发之Hibernate详解（二）——Hibernate的持久化类状态与转换、以及一级缓存详解、关联关系的映射（一对多、多对多、级联）

目录(?)[+]

持久化对象的状态

 Hibernate持久化对象存在三种状态：

瞬时态 transient:(临时态)  不存在持久化标识OID，尚未与Hibernate  Session关联对象，被认为是瞬时状态，失去引用将被JVM回收。特点：无持久化标识OID，未与Session关联。

持久态 persistent:存在持久化标识OID，与当前Session有关联，并且相关联的Session没有关闭，并且事务未提交。特点：存在持久化标识OID，与Session关联。*****注意 持久态对象具有自动更新数据库的能力。

托管态 detached:存在持久化标识OID，但没有与当前session关联，托管状态发送改变  Hibernate不能检测到。特点：存在持久化标识OID，未与Session关联。

测试Hibernate中持久化对象的状态：

对象的状态总结：

持久化对象状态转换：

三种状态的获得与转换如下：

瞬时态：

       *获得：

                Book book= new Book();

       *瞬时—>持久

                * save(book);

                * save() / saveOrUpdate();

       *瞬时—>脱管

                * book.setId(1);

持久态：

       *获得：

                Book book = (Book)session.get(Book.class, 1);

       *持久—>瞬时

                * delete(book);

                     *特殊状态：删除态.（被删除的状态，不建议去使用）

       *持久—>脱管

                * session.close();

                * close() / clear() / evict();

托管态：

       *获得：

                Book book = new Book();

                book.setId(1);

       *脱管—>持久

                * session.update();

                * update() / saveOrUpdate() / lock();

       *脱管—>瞬时

                * book.setId(null);

注意：持久态对象有自动更新数据库的能力;

Hibernate的一级缓存（Session缓存）

什么是缓存：

       * 缓存将数据库/硬盘上文件中的数据，放入到缓存中(就是内存中的一片空间)。当再次使用的时候，可以直接从内存中获得。

缓存的好处：

       * 提升程序运行的效率。缓存技术是Hibernate的一个优化的手段。

Hibernate分成两个基本的缓存：

• 一级缓存：Session级别的缓存.一级缓存与Session的生命周期是一致的。自带的，不可卸载。
• 二级缓存：SessionFactory级别的缓存，不是自带的。

深入理解Hibernate中的Session缓存：

• 在Session接口的实现中包含一系列的Java集合，这些Java集合构成了Session缓存。只要Session实例没有结束生命周期，存放在它缓存中的对象也不会结束生命周期。
• 当session的save()方法持久化一个对象时，该对象被载入缓存，以后即使程序中不再引用该对象，只要缓存不清理，该对象仍然处于生命周期中。当试图get()、load()对象时，会判断缓存中是否存在该对象，有则返回，此时不查询数据库。没有再查询数据库。
• Session能够在某些时间点，按照缓存中对象的变化来执行相关的SQL语句，来同步更新数据库，这一过程被称为刷出缓存(flush)。

默认情况下Session在以下时间点刷出缓存：

• 当应用程序调用Transaction的commit()方法时，该方法先刷出缓存(session.flush() )，然后再向数据库提交事务(tx.commit() )。
• 当应用程序执行一些查询操作时，如果缓存中持久化对象的属性已经发生了变化，会先刷出缓存，以保证查询结果能够反映持久化对象的最新状态。
• 手动调用Session的flush()方法。

注意：flush与commit是有区别的，区别如下：

• flush()方法进行清理缓存的操作,执行一系列的SQL语句,但不会提交事务;commit()方法会先调用flush()方法,然后提交事务. 
• 提交事务意味着对数据库所做的更新会永久保持下来 
• 所谓清理,是指Hibernate 按照持久化象的状态来同步更新数据库
• Flush()后只是将Hibernate缓存中的数据提交到数据库,如果这时数据库处在一个事物当中,则数据库将这些SQL语句缓存起来,当Hibernate进行commit时,会告诉数据库,你可以真正提交了,这时数据才会永久保存下来,也就是被持久化了.
• commit针对事物的
• flush针对缓存的
• 同步到数据库中后只要没有commit还是可以rollback的

Hibernate快照区：

当session加载了customer对象后，会为customer对象的值类型的属性复制一份快照。当刷出缓存时，通过比较对象的当前属性和快照，来判断对象的哪些属性发生了变化  

                

 向一级缓存中存入数据的时候，放入一级缓存区和缓存快照区，当更新了一级缓存的数据的时候，事务一旦提交，会比对一级缓存和快照区，如果数据一致，不更新，如果数据不一致，自动更新数据库。

Hibernate管理一级缓存：

一级缓存是与session的生命周期相关的.session生命周期结束，一级缓存就结束了。

• clear() / evict() / flush() / refresh()  管理一级缓存
• clear()                  ：清空一级缓存中的所有对象。
• evict(Object obj)  ：清空一级缓存中的某个对象。
• flush()                  ：刷出缓存。
• refresh(Object obj)：将快照区的数据重新覆盖了一级缓存的数据。

清理session的缓存，测试flush和clear、evict方法的使用

session的flush方法让缓存的数据刷出到数据库
session的clear方法清空缓存数据         

执行过程：调用session的flush方法后会立即发出查询语句，然后将id为1的customer对象分别复制一份到session的快照区与缓存区。获取customer2时会首先查找比对缓存区中的对象 发现已经存在了OID为1的Customer对象，不再查询数据库，立即返回缓存区中的对应对象。最后调用session的flush方法，会将一级缓存区中的所有对象清除，获取customer3时，先上session一级缓存区中进行查找，没有查找到，再向数据库发出SQL语句进行查询。

session的evict方法清空指定对象一级缓存数据，使对象变为离线

执行过程：第一次获取customer对象 会发出SQL语句进行查询（因为在Session缓存区中没有找到），从数据库查询成功后，还是先将customer各复制一份到Session的缓存区与快照区。调用Session的evict方法，会将customer对象从Session的缓存区与快照区中清除，再次获取时 就会发出SQL查询语句。

refresh刷新一级缓存

当session.load 加载Customer对象后，修改city为 武汉，调用refresh方法更新一级缓存，此时设置的武汉重新被数据表中记录覆盖

一级缓存的刷出时机

清理session的缓存(设置缓存的flush模式)
   session.setFlushMode(FlushMode.AUTO);

FlushMode：

常量：

       * ALWAYS  ：每次查询的时候都会刷出；手动调用flush；事务提交的时候。

       * AUTO      ：默认值。有些查询会刷出；手动调用flush；事务提交的时候。

       * COMMIT  ：在事务提交的时候，手动调用flush的时候。

       * MANUAL  ：只有在手动调用flush的时候才会刷出。

****** 严格程度：MANUAL > COMMIT > AUTO > ALWAYS

ALWAYS和AUTO的区别：当hibernate缓存中的对象被改动之后，会被标记为脏数据（即与数据库不同步了）。当 session设置为FlushMode.AUTO时，hibernate在进行查询的时候会判断缓存中的数据是否为脏数据，是则刷数据库，不是则不刷， 而always是只要执行查询都直接刷新，不进行任何判断。很显然auto比always要高效得多 

看如下代码图：

会不会执行更新到数据库？

是不会更新到数据库的，因为设置了MANUAL模式，只有在手动调用flush的时候才会刷出缓存。

操纵持久化对象的方法

操作持久化对象 —save()

Session的save()方法保存一条记录，使一个瞬时态的对象转变为持久态对象。

Session的save()方法可以完成以下操作：

• 把瞬时态对象加入Session缓存中，使它进入持久化状态。
• 选用映射文件指定的标识符生成器，为持久化对象分配唯一的OID，在使用代理主键的情况下，setId()方法为瞬时对象设置的OID是无效的。
• 计划执行一条insert语句，把Customer对象当前的属性值组装到insert语句中。

Hibernate通过持久化对象的OID来维持它和数据库相关记录的对应关系，当Customer对象处于持久化状态时，不允许程序随意修改它的ID。

操纵持久化对象—update()

Session的update方法使一个托管对象转变为持久化对象，并且计划执行一条update语句。

以上默认情况下 不管Customer对象c的内容是否发生改变，都会执行更新操作。

若希望Session仅当修改了Customer对象的属性时，才执行update()语句，可以把映射文件中<class> 元素标签上的属性值select-before-update（更新之前先查询）设置为true，该属性的默认值是false。

当update()方法关联一个托管对象时，如果在Session的缓存中已经存在相同OID的持久化对象，就会抛出异常。

执行过程：执行evict(c);方法后对象c变为托管态的游离对象。查询获得c1对象并存入session缓存中，更新游离对象c时会从缓存区中查找和c1相同的对象（注意：缓存即内存，在缓存中查找相同对象是按照对象在内存中的地址进行比对的 因为c和c1的内存地址不同，c会保存到session缓存区中，这时Hibernate检查出缓存区中两个内存地址不同的对象拥有相同的OID时就会抛出异常，因为Hibernate是按照OID进行比对的，是不允许缓存区中存在两个内存地址不同而OID相同的对象的）

抛出异常的原因是：两个不同的对象拥有相同的OID。

当update()方法关联一个托管对象时，如果在数据库中不存在相应的记录，也会抛出异常。

操作持久化对象—saveOrUpdate()

saveOrUpdate()：

该方法同时包含save方法和update方法，如果参数是瞬时对象就调用save方法，如果是脱管对象就调用update方法，如果是持久化对象就直接返回。

判断对象为临时对象的标准：

• 标准一：Java对象的OID为null
• 标准二：映射文件中为<id>标签设置了unsaved-value属性，并且Java对象的OID的取值与这个unsaved-value属性值匹配。

根据以上判断临时对象的标准 id=null为临时对象。但可以定义属性id为int id;

* 此时id的默认值为0而不是null。如果将id设置为1，而此时应该在<id>中设置unsaved-value的值为除了1之外的值。此时应该执行更新id为1这条记录的操作(如果所设置的id值在数据库表中不存在则抛出异常)

* 如果我们要执行的是插入操作。这时，可以在<id>标签上设置属性unsaved-value=1，与在JavaBean中定义的int id=1对应，2个值相等则执行插入操作。其中unsaved-value=0（默认值）

即saveOrUpdate的执行流程如下：

首先判断要操作的对象是否有id值 如果id值存在说明是要么是查询出来的持久化对象要么是脱管状态或瞬时态的对象。如果是持久态的对象，则直接返回 ，如果不是持久态的对象 首先查找这个对象所属类对应的hbm.xml中<id>标签上的unsaved-value属性 如果对象的id值与unsaved-value的值相同 则判断此对象为瞬时态对象 执行save的插入操作，如果对象的id值不与unsaved-value的的相同 则执行update更新操作，如果在数据库对应表中查询到id值相同的记录则更新这条记录。如果没有查询到 则抛出异常（因为update是不允许更新数据库中不存在的数据的）。如果id不存在则一定为瞬时态的对象，直接执行save的插入操作。

示例如下：

如果参数是瞬时对象就用save方法

如果是脱管对象就用update方法

如果是持久化对象就直接返回

操纵持久化对象-get()  load()

都可以根据给定的 OID 从数据库中加载一个持久化对象
区别:当数据库中不存在与 OID 对应的记录时, load() 方法抛出 ObjectNotFoundException 异常, 而 get() 方法返回 null
两者采用不同的延迟检索策略

操纵持久化对象-delete

Session的delete()方法既可以删除一个托管对象，也可以删除一个持久化对象

如果参数是持久化对象，就执行一个delete语句，若为托管对象，先使游离对象被session关联。

计划执行一条delete语句。

把对象从Session缓存中删除，使该对象进入脱管状态。刷新缓存后，该对象从数据库中删除。

Hibernate关联关系映射

系统设计中的三种实体关系

实体之间有三种关系：

 * 一对多：

       * 一个用户，生成多个订单，每一个订单只能属于一个用户。

       *建表原则：在多的一方创建一个字段，作为外键指向一的一方的主键。

* 多对多：

       *一个学生可以选择多门课程，一个课程可以被多个学生选择。

       *建表原则：创建中间表，中间表至少有两个字段，分别作为外键指向多方的主键。

*一对多：（特殊，使用最少）

       *一个公司只能有一个注册地址，一个注册地址只能被一个公司使用(如果没有特殊的需求，可以建同一张表)

       *建表原则：

             *唯一外键：一对一的双方，假设任意一方是多的关系，需要在多的一方创建一个字段，作为外键 指向一的   一方的主键。但是在外键添加一个unique。

             *主键对应：一对一的双方通过主键进行关联。

Hibernate关联关系映射：

Hibernate是采用Java对象关系来描述数据表实体间的关系

建立多对一关系映射

客户和订单是典型的一对多关联关系

在Order.hbm.xml配置<many-to-one>

<many-to-one  name="customer" class="cn.itcast.many2one.Customer"  column="customer_id" ></many-to-one>

• name：设定待映射的持久化类的属性名称，即关联对象的属性的名称。
• column：设定和持久化类的属性对应的表的外键。
• class：关联对象类的全路径。
• not-null：是否允许为空。

建立一对多关系映射

仍然采用客户和订单系统

在Customer.hbm.xml添加<set>元素

<set  name="orders">

     <key column="customer_id" not-null="true"><key>

     <one-to-many  class="cn.itcast.one2many.Order" />

</set>

• name：设定Customer中集合类型属性名称。
• <key>中的column：用来描述一对多多的一方的外键名称。
• not null：设置外键字段非空约束。
• <one-to-many>：设置一对多映射关系。
• class：设置映射关联目标类的全路径。

注意：一对多是具有双向性的，如果需要在一的一方持有多方的引用，则在一的一方类中添加多方类型的集合引用。在一方的hbm.xml映射文件中添加<set> 标签 在<set>标签中添加子标签<key>和<one-to-many>。如果在多方的类中需要引用一方，则在多方对应的类中添加一方的对象引用，然后在多方类对应的hbm.xml映射文件中添加<many-to-one>标签。如果都需要引用，则双方全部配置即可。注意：一方和多方的关系是靠多方对应表中指向一方主键的外键来指定的。如果需要指定多个一对多或多对一，即一方中有多个集合（都存放多方的对象），则需要在一方的映射文件中设置多个<set>集合 或在多方的映射表中设置多个<many-to-one>标签。注意一个<set>标签的子标签<key>中属性column（多方的表中的外键名称）是和<many-to-one>标签中的column一一对应相同的。即多方类中的多个一方对象的引用和一方类中的包含多方的多个集合以及一方映射表中<one-to-many>中子标签的column属性值 和多方映射文件中<many-to-one>的column属性值是一一对应相同的。

<one-to-many> ——<many-to-one>  （一一对应）

<key column="外键名称"></key> —— <many-to-one>中属性column="外键名称"  （对应相同）

一对多保存操作

建立双向关联，保存客户 同时也要保存订单。

一对多保存操作——级联保存

采用级联保存操作 cascade="save-update"

保存多方级联保存相关联的一方

注意：如果在多方（Order）对应的关系映射中没有设置cascade=true属性 那么只保存了Order对象，是无法保存其关联的一方对象（Customer）的，并且会抛出org.hibernate.TransientObjectException异常，表示无法保存没有与Session关联的瞬时态对象。如果想在保存多方对象(order)时级联保存关联的一方对象(customer)  需要在多方对应的映射文件的实体关系<many-to-one>标签上设置级联属性 cascade="save-update"即可。

保存一方，级联保存相关联的多方。

测试保存Customer对象，将瞬时态的Order对象关联到Customer对象

如果想只保存一方，级联保存或更新关联的多方， 则需要在一方对应的映射文件中的集合标签上设置cascade属性.

一对多保存——对象导航

在配置文件中需要配置2端cascade="save-update"

1、order1关联到customer而customer没有关联到order1。

2、customer关联到order2，order3  而order2和order3没有关联到customer

问题1：session.save(order1) 插入几条数据？

会插入4条记录，因为是双向级联的，保存order1时 会级联保存order1相关联的customer对象，插入两条记录，在级联保存customer对象时 customer会级联保存customer相关联的对象order2和order3 又会插入两条记录 所以一共会插入4条记录。

问题2：session.save(customer);会插入几条记录？

会插入三条记录，在保存customer时 会级联保存order2和order3。由于保存的对象中没有关联到order1，所以无法级联保存order1。

问题3：session.save(order2)插入几条记录？

只会插入一条记录，在保存order2时，由于order2没有关联任何对象。所以只能保存自身。

一对多删除操作——级联删除

默认情况下，Hibernate是不会级联删除的，假设只删除一方(customer)，并不会删除多方(customer关联的所有order) 只是将与customer关联的order对应表中指向customer的外键置为null。

如果想删除一方时 也同时删除相关联的多方或者删除多方时也删除相关联的一方，就需要设置级联删除，采用级联删除操作  cascade="delete"

删除多方(订单)时级联删除对应的一方(客户)

会发现删除订单后 对应的客户信息也被删除了，如果想在删除某个多方时级联删除对应的一方，需要在多方对应的映射文件中的<many-to-one>标签上设置级联删除属性  cascade="delete"

删除一方(客户)时级联删除对应的多方(对应的所有订单)

发现删除客户数据时，对应的订单数据也会被删除。如果想删除一方时，级联删除多方（对应的所有订单）需要在一方对应的映射文件中的集合属性上添加级联删除属性cascade="delete"

从查询的客户对象中移除订单对象，订单对象是否删除？

发现从客户对应的所有订单中移除某个订单，被移除的订单被删除。原因是从查询的客户对象中移除某个订单，会把被移除订单中指向客户的外键置为null，这时被移除的订单就成了"孤儿", 一旦在客户的映射文件的集合标签上添加了孤儿删除的属性即cascade="delete-orphan" Hibernate就会在移除订单后 将外键为null的订单级联删除。

cascade属性的配置

在对象-关系映射文件中，用于映射持久化类之间关联关系的元素，<set>、<many-to-one>和<one-to-one>都有一个cascade属性，它用于指定如何操作与当前对象关联的其他对象。

cascade有以下属性值：

总结：

none :不使用级联
dave-update :保存或更新的时候级联
delete :删除的时候级联
all :除了孤儿删除以外的所有级联.
delete-orphan :孤儿删除(孤子删除).
* 仅限于一对多.只有一对多时候,才有父子存在.认为一的一方是父亲,多的一方是子方.
* 当一个客户与某个订单解除了关系.将外键置为null.订单没有了所属客户,相当于一个孩子没有了父亲.将这种记录就删除了.
all-delete-orphan :包含了孤儿删除的所有的级联.

处理双向维护的多余SQL问题

双向维护会产生多余的SQL语句

上面的代码为什么产生两条update语句？如何产生一条语句呢,完成上面的功能呢?
Hibernate: update orders set order_number=?, price=?, customer_id=? where id=?
Hibernate: update orders set customer_id=? where id=?

更改订单表id=6的customer_id=3更改为4
* 使用session缓存的监控功能剖析产生两条update语句的原因：

解决方法：设置inverse属性（单向维护）

通过inverse属性来设置由双方关联的哪一方来维护表和表之间的外键关系。inverse=false的为主动方，inverse=true的为被动方。由主动方负责维护关联关系（配置inverse="true"：在哪一端配置，那么那一端就放弃了外键的维护权）

一般情况下一的一方去放弃。

注意：cascade和inverse是有很大区别的

cascade：操作关联对象。

inverse：控制外键的维护。

示例如下：

在一的一方(Customer)设置inverse="true" 由集合端来管理关系

在Customer.hbm.xml中的<set>上配置 cascade="save-update" inverse="true"

发现客户能存到数据库，订单也能存到数据库是因为在Customer的映射关系文件中的<set>集合上设置了cascade="save-update" 级联保存或更新。但是级联保存的订单指向Customer主键的外键属性为null，是因为设置了inverse="true"  即Customer放弃了外键的维护权。

一对多关联中的父子关系

所谓父子关系：
是指父方来控制子方的持久化生命周期，子方对象必须和一个父方对象关联。

解除关联关系——父子关系

当customer.hbm.xml的<set>元素的cascade属性取值为all-delete-orphan,
  Hibernate会按照如下方式处理customer对象：
1.当保存或更新customer对象时，级联保存或更新所有关联的order对象，
  相当于save-update.
2.当删除customer对象时，级联删除所有的order对象，相当于delete。
3.删除不再和customer对象关联的所有order对象。
   当关联双方存在父子关系时，就可以把父方的cascade属性设为all-delete-orphan.
注意：父子关系只是针对于一对多而言

多对多关联关系映射

多对多的实体关系模型也是很常见的，比如学生和课程的关系。一个学生可以选修多门课程，一个课程可以被多名学生选修。在关系型数据库中对于多对多关联关系的处理一般采用中间表的形式，将多对多的关系转化成两个一对多的关系。 

• 双向 n-n 关联需要两端都使用集合属性
• 双向n-n关联必须使用中间表
• 集合属性应增加 key 子元素用以映射外键列, 集合元素里还应增加many-to-many子元素关联实体类
• 在双向 n-n 关联的两边都需指定连接表的表名及外键列的列名. 两个集合元素 set 的 table 元素的值必须指定，而且必须相同。

• set元素的两个子元素：key 和 many-to-many 都必须指定 column 属性，
• 其中，key中的column属性 和 many-to-many 中的column属性分别指定本持久化类和关联类在连接表中的外键列名，
• 因此两边的 key 与 many-to-many 的column属性交叉相同。也就是说，一边的set元素的key的 cloumn值为a,many-to-many 的 column 为b；则另一边的 set 元素的 key 的 column 值 b,many-to-many的 column 值为 a.  

具体的类与映射关系的设置如下：

测试保存：

注意：之所以能保存成功，是因为在其中的任意一方(student)对应的<many-to-many>标签上设置的inverse="true" 

也就是说双向的多对多必须有一方放弃主键的维护。若双方没有任何一方放弃主键的维护，则会抛出约束异常，是因为双方维护会产生多余的SQL，这时多余的SQL就是向中间表里插入两次相同的外键记录作为中间表的联合主键，所以会抛出约束冲突异常。

解除1号学生和1号课程的关联关系

改变1号学生和2号学生课程的关联关系，改为1号学生和1号课程。

删除1号课程

会抛出异常：org.hibernate.exception.ConstraintViolationException: Could not execute JDBC batch update
这个异常表示的是约束冲突异常 因为在中间表中还有外键指向到c1的主键。

如果想解决异常 ：

方式一：  级联删除，在Course对应的<many-to-many>标签上添加级联删除的属性。这样一来删除了c1就会级联删除与c1相关联的所有students。如果Student中也设置了级联删除的属性，在级联删除与c1相关的students时 也会级联删除students相关联的所有courses。因此很少使用级联删除。

方式二：在代码中进行双向解除关联。会将中间表中对应的联合主键记录给删除。基本上都是使用这种方式。

删除1号课程的同时，要把1号和2号学生删除

设置多个多对多：

打个比方：一个QQ联系人和QQ群是多对多的关系，一个QQ群有多个联系人，一个联系人有多个QQ群。但是一个联系人相关联的QQ群又分为两种已经加入的QQ群是一个集合，正在审核加入的QQ群是另一集合。这种关系要设置两个多对多集合（注意：切不可设置flag标志进行区别）设置要在双方对应的映射文件中各设置两个集合，分别指定不同的中间表，才可以完成这种多对多映射。

映射一对一主键双向关联

一对一关联指两个表之间的记录时一一对应的关系。分为两种：唯一外键关联和主键关联。

一对一方式一：唯一外键关联

比如一家公司(Company)和它所在的地址(Address)。在业务逻辑中要求一家公司只有唯一的地址，一个地址也只有一家公司。 下图表现为外键关联关系。

对于基于外键的1-1关联，其外键可以存放在任意一边，在需要存放外键一端，增加 many-to-one 元素。为 many-to-one元素增加 unique=“true” 属性来表示为1-1关联，并用name属性来指定关联属性的属性名

另一端需要使用one-to-one元素，该元素使用 property-ref 属性指定使用被关联实体主键以外的字段作为关联字段

具体设置配置如下：

测试唯一性（会报错）

一对一方式二：主键关联

一对一的另一种解决方式就是主键关联，在这种关联关系中，要求两个对象的主键必须保持一致，通过两个表的主键建立关联关系，无须外键参与。

基于主键的映射策略：指一端的主键生成器使用foreign策略，表明根据"对方"的主键来生成自己的主键，自己并不能独立生成主键。<param>子元素指定使用当前持久化类的那个属性作为"对方"。

采用foreign主键生成策略的一端增加one-to-one元素映射关联属性，其one-to-one还应增加constrained="true"属性，另一端(company)增加one-to-one元素映射关联属性。

constrained(约束):指定为当前持久化类对应的数据库表的主键添加一个外键约束，引用被关联的对象(“对方”)所对应的数据库表主键

具体设置和映射如下：

测试保存

注意：无论是那种FlushMode, 在事务中查询到的数据都是更改后最新的数据,并未持久化到数据库。除了MANUAL必须手动flush后commit才能持久化到数据库，别的模式不管是否手动调用flush方法，最后commit时 都会持久化到数据库。举例如下：session.save():实体被纳入session缓存，session计划执行sql，此时查询不会有结果（无插入sql的执行）;
session.flush():session“清理”缓存，发送执行sql，但不提交事务，此时在同一session中执行查询可以查询到结果（处于同一个数据库会话，尽管该会话的事物尚未提交，数据库中无真实的数据，此时查询到的应该是数据库本身事务机制的缓存），但在另外的查询中不会有结果（比如在native mysql中，因为不处于同一个数据库会话中）；
commit():发送执行sql并提交事务；事务完成

实例演示代码如下：

  

其中demo1测试持久化对象的状态与一级缓存。demo2测试一对多的关系。demo3测试多对多的关系。

HibernateUtils

[java]  view plain  copy

1. <span style="font-size:18px;">package cn.test.hibernate3.utils;  
2.   
3. import org.hibernate.Session;  
4. import org.hibernate.SessionFactory;  
5. import org.hibernate.cfg.Configuration;  
6.   
7. /** 
8.  * Hibernate抽取工具类 
9.  *  
10.  */  
11. public class HibernateUtils {  
12.     private static Configuration configuration;  
13.     private static SessionFactory sessionFactory;  
14.   
15.     static {  
16.         configuration = new Configuration().configure();  
17.         sessionFactory = configuration.buildSessionFactory();  
18.     }  
19.   
20.     public static Session openSession() {  
21.         return sessionFactory.openSession();  
22.     }  
23.   
24.     public static void main(String[] args) {  
25.         openSession();  
26.     }  
27. }  
28. </span>  

log4j.properties

[plain]  view plain  copy

1. <span style="font-size:18px;">### direct log messages to stdout ###  
2. log4j.appender.stdout=org.apache.log4j.ConsoleAppender  
3. log4j.appender.stdout.Target=System.err  
4. log4j.appender.stdout.layout=org.apache.log4j.PatternLayout  
5. log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n  
6.   
7. ### direct messages to file mylog.log ###  
8. log4j.appender.file=org.apache.log4j.FileAppender  
9. log4j.appender.file.File=c\:mylog.log  
10. log4j.appender.file.layout=org.apache.log4j.PatternLayout  
11. log4j.appender.file.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n  
12.   
13. ### set log levels - for more verbose logging change 'info' to 'debug' ###  
14.   
15. log4j.rootLogger=off, stdout   
16. </span>  

Book

[java]  view plain  copy

1. <span style="font-size:18px;">package cn.test.hibernate3.demo1;  
2.   
3. public class Book {  
4.     private Integer id;  
5.     private String name;  
6.     private String author;  
7.     private Double price;  
8.   
9.     public Integer getId() {  
10.         return id;  
11.     }  
12.   
13.     public void setId(Integer id) {  
14.         this.id = id;  
15.     }  
16.   
17.     public String getName() {  
18.         return name;  
19.     }  
20.   
21.     public void setName(String name) {  
22.         this.name = name;  
23.     }  
24.   
25.     public String getAuthor() {  
26.         return author;  
27.     }  
28.   
29.     public void setAuthor(String author) {  
30.         this.author = author;  
31.     }  
32.   
33.     public Double getPrice() {  
34.         return price;  
35.     }  
36.   
37.     public void setPrice(Double price) {  
38.         this.price = price;  
39.     }  
40.   
41.     public String toString() {  
42.         return "Book [id=" + id + ", name=" + name + ", author=" + author  
43.                 + ", price=" + price + "]";  
44.     }  
45.   
46. }  
47. </span>  

Book.hbm.xml

[html]  view plain  copy

1. <?xml version="1.0" encoding="UTF-8"?>  
2. <!DOCTYPE hibernate-mapping PUBLIC   
3.     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"  
4.     "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">  
5. <hibernate-mapping>  
6.     <class name="cn.test.hibernate3.demo1.Book" table="book" select-before-update="true">  
7.         <!-- 配置唯一标识 -->  
8.         <id name="id" column="id" unsaved-value="-1">  
9.             <generator class="native" />  
10.         </id>  
11.         <!-- 配置普通属性 -->  
12.         <property name="name" column="name" length="30" />  
13.         <property name="author" column="author" length="20" />  
14.         <property name="price" column="price" />  
15.     </class>  
16. </hibernate-mapping>  

HibernateTest1

[java]  view plain  copy

1. package cn.test.hibernate3.demo1;  
2.   
3. import java.util.List;  
4.   
5. import org.hibernate.FlushMode;  
6. import org.hibernate.Session;  
7. import org.hibernate.Transaction;  
8. import org.junit.Test;  
9.   
10. import cn.test.hibernate3.demo1.Book;  
11. import cn.test.hibernate3.utils.HibernateUtils;  
12.   
13. /** 
14.  * Hibernate的测试类 
15.  *  
16.  */  
17. public class HibernateTest1 {  
18.   
19.     @Test  
20.     // 区分持久化对象的三种状态  
21.     public void demo1() {  
22.         // 1.创建Session  
23.         Session session = HibernateUtils.openSession();  
24.         // 2.开启事务  
25.         Transaction tx = session.beginTransaction();  
26.   
27.         // 向数据库中保存一本图书  
28.         Book book = new Book(); // 瞬时态:没有唯一OID，没有与Session关联  
29.         book.setName("Hibernate开发");  
30.         book.setAuthor("孙XX");  
31.         book.setPrice(65d);  
32.   
33.         session.save(book);  
34.   
35.         // 3.事务提交  
36.         tx.commit();  
37.         // 4.释放资源  
38.         session.close();  
39.   
40.         book.setName("Struts2开发"); // 托管态：有唯一的标识，没有与Session关联  
41.     }  
42.   
43.     @Test  
44.     // 测试持久态的对象自动更新数据库  
45.     public void demo2() {  
46.         // 1.创建Session  
47.         Session session = HibernateUtils.openSession();  
48.         // 2.开启事务  
49.         Transaction tx = session.beginTransaction();  
50.   
51.         // 获得一个持久态的对象  
52.         Book book = (Book) session.get(Book.class, 1);  
53.         book.setName("Struts2开发");  
54.   
55.         // 3.事务提交  
56.         tx.commit();  
57.         // 4.释放资源  
58.         session.close();  
59.     }  
60.   
61.     @Test  
62.     // 证明一级缓存的存在  
63.     public void demo3() {  
64.         // 1.创建Session  
65.         Session session = HibernateUtils.openSession();  
66.         // 2.开启事务  
67.         Transaction tx = session.beginTransaction();  
68.   
69.         // save方法可以向一级缓存中存放数据  
70.         /* 
71.          * Book book=new Book(); book.setName("JQuery"); book.setAuthor("张XX"); 
72.          * book.setPrice(45d); 
73.          *  
74.          * Integer id=(Integer) session.save(book); 
75.          *  
76.          * Book book2=(Book) session.get(Book.class, id); 
77.          *  
78.          * System.out.println(book2); 
79.          */  
80.   
81.         // 分别用get执行两次查询  
82.         Book book1 = (Book) session.get(Book.class, 1); // 马上发生SQL查询  
83.         System.out.println(book1);  
84.   
85.         Book book2 = (Book) session.get(Book.class, 1);// 不发生SQL,因为使用一级缓存的数据  
86.         System.out.println(book2);  
87.   
88.         // 3.事务提交  
89.         tx.commit();  
90.         // 4.释放资源  
91.         session.close();  
92.     }  
93.   
94.     @Test  
95.     // 深入理解一级缓存的结构：快照区  
96.     public void demo4() {  
97.         // 1.创建Session  
98.         Session session = HibernateUtils.openSession();  
99.         // 2.开启事务  
100.         Transaction tx = session.beginTransaction();  
101.   
102.         // 获得一个持久态的对象  
103.         Book book = (Book) session.get(Book.class, 1);  
104.         book.setName("Spring3开发");  
105.   
106.         // 3.事务提交  
107.         tx.commit();  
108.         // 4.释放资源  
109.         session.close();  
110.     }  
111.   
112.     @Test  
113.     // 一级缓存的管理：clear/evict()  
114.     public void demo5() {  
115.         // 1.创建Session  
116.         Session session = HibernateUtils.openSession();  
117.         // 2.开启事务  
118.         Transaction tx = session.beginTransaction();  
119.   
120.         // 获得一个持久态的对象  
121.         Book book1 = (Book) session.get(Book.class, 1);  
122.         Book book2 = (Book) session.get(Book.class, 2);  
123.         System.out.println(book1);  
124.         System.out.println(book2);  
125.   
126.         // session.clear(); // 清空一级缓存区域  
127.         session.evict(book1); // 清空一级缓存的某个区域  
128.   
129.         Book book3 = (Book) session.get(Book.class, 1);  
130.         Book book4 = (Book) session.get(Book.class, 2);  
131.         System.out.println(book3);  
132.         System.out.println(book4);  
133.   
134.         // 3.事务提交  
135.         tx.commit();  
136.         // 4.释放资源  
137.         session.close();  
138.     }  
139.   
140.     @Test  
141.     // 一级缓存的管理：flush()刷出缓存  
142.     // 默认情况下 如果没有手动调用flush方法，会在commit时隐式的调用flush方法 发出SQL语句  
143.     // 默认情况下 如果手动的调用了flush方法，会在flush的时候发出SQL语句 commit的时候就不再发出  
144.     public void demo6() {  
145.         // 1.创建Session  
146.         Session session = HibernateUtils.openSession();  
147.         // 2.开启事务  
148.         Transaction tx = session.beginTransaction();  
149.   
150.         Book book = (Book) session.get(Book.class, 1);  
151.         book.setName("Hibernate3开发");  
152.   
153.         session.flush(); // 发出update语句  
154.   
155.         // 3.事务提交  
156.         tx.commit();  
157.         // 4.释放资源  
158.         session.close();  
159.     }  
160.   
161.     @Test  
162.     // 一级缓存的管理：refresh() 将快照区的数据，覆盖了一级缓存的数据  
163.     public void demo7() {  
164.         // 1.创建Session  
165.         Session session = HibernateUtils.openSession();  
166.         // 2.开启事务  
167.         Transaction tx = session.beginTransaction();  
168.   
169.         Book book = (Book) session.get(Book.class, 1);  
170.         book.setName("PHP开发");  
171.   
172.         session.refresh(book);  
173.         // 3.事务提交  
174.         tx.commit();  
175.         // 4.释放资源  
176.         session.close();  
177.     }  
178.   
179.     @Test  
180.     // 一级缓存的输出时机（了解）  
181.     public void demo8() {  
182.         // 1.创建Session  
183.         Session session = HibernateUtils.openSession();  
184.         // session.setFlushMode(FlushMode.COMMIT); // 事务提交  
185.         session.setFlushMode(FlushMode.MANUAL); // 只有手动调用flush的时候才会发送  
186.         // 2.开启事务  
187.         Transaction tx = session.beginTransaction();  
188.   
189.         Book book = (Book) session.get(Book.class, 1);  
190.         book.setName("JavaScript开发");  
191.   
192.         List<Book> list = session.createQuery("from Book").list();  
193.         System.out.println(list);  
194.         Book book2 = (Book) session.get(Book.class, 1); // 不发送SQL,从一级缓存中获取数据  
195.         System.out.println(book2);  
196.   
197.         // 3.事务提交  
198.         tx.commit();  
199.   
200.         session.flush();  
201.         // 4.释放资源  
202.         session.close();  
203.     }  
204.   
205.     @Test  
206.     // save方法  
207.     public void demo9() {  
208.         // 1.创建Session  
209.         Session session = HibernateUtils.openSession();  
210.         // 2.开启事务  
211.         Transaction tx = session.beginTransaction();  
212.   
213.         Book book = new Book(); // 瞬时态对象  
214.         book.setName("网页平面设计");  
215.         book.setAuthor("王XX");  
216.         book.setPrice(32d);  
217.   
218.         session.save(book); // 持久态  
219.   
220.         // 3.提交事务  
221.         tx.commit();  
222.         // 4.释放资源  
223.         session.close();  
224.     }  
225.       
226.     @Test  
227.     // update方法:更新一条记录,将托管对象转成持久对象  
228.     public void demo10(){  
229.         // 1.创建Session  
230.         Session session=HibernateUtils.openSession();  
231.         // 2.开启事务  
232.         Transaction tx=session.beginTransaction();  
233.   
234.         Book book=new Book(); // 瞬时态  
235.         book.setId(1); // 托管态  
236.         book.setName("MyBatis开发");   
237.           
238.         // 默认情况下，每次update对象都会执行update操作  
239.         /* 如果在Book对应的hbm映射文件的class标签上设置了select-before-update="true" 
240.          * 则只有当更新的对象和数据库中对应的数据不一致时才会发出更新语句update 
241.          * */  
242.         session.update(book); // 持久态  
243.   
244.         // 3.提交事务  
245.         tx.commit();  
246.         // 4.释放资源  
247.         session.close();  
248.     }  
249.       
250.     @Test  
251.     // saveOrUpdate方法：保存或更新一条记录  
252.     //  如果对象时瞬时，执行save操作，如果对象是脱管，执行update操作  
253.     // 如果设置的id是数据库中没有保存的.可以在映射文件的<id>上设置unsaved-value="-1"执行保存操作  
254.     public void demo11(){  
255.         // 1.创建Session  
256.         Session session=HibernateUtils.openSession();  
257.         // 2.开启事务  
258.         Transaction tx=session.beginTransaction();  
259.   
260.         /*   
261.         Book book = new Book();//瞬时态. 
262.         book.setName("MySQL数据库"); 
263.          
264.         session.saveOrUpdate(book);// 执行保存. 
265.          
266.          
267.         Book book = new Book();//瞬时态. 
268.         book.setId(1); // 脱管态: 
269.         book.setName("Java大全"); 
270.          
271.         session.saveOrUpdate(book);// 执行更新. 
272.         */        
273.           
274.         Book book = new Book();//瞬时态.  
275.         book.setId(-1); // 脱管态:  
276.         book.setName("Spring大全");  
277.           
278.         session.saveOrUpdate(book);// 执行保存.  
279.   
280.         // 3.提交事务  
281.         tx.commit();  
282.         // 4.释放资源  
283.         session.close();  
284.     }  
285.       
286.   
287. }  

Customer

[java]  view plain  copy

1. package cn.test.hibernate3.demo2;  
2.   
3. import java.util.HashSet;  
4. import java.util.Set;  
5.   
6. /** 
7.  * 客户的实体 
8.  *  
9.  */  
10. public class Customer {  
11.     private Integer cid;  
12.     private String cname;  
13.     // 一个客户有多个订单  
14.     private Set<Order> orders = new HashSet<Order>();  
15.   
16.     public Integer getCid() {  
17.         return cid;  
18.     }  
19.   
20.     public void setCid(Integer cid) {  
21.         this.cid = cid;  
22.     }  
23.   
24.     public String getCname() {  
25.         return cname;  
26.     }  
27.   
28.     public void setCname(String cname) {  
29.         this.cname = cname;  
30.     }  
31.   
32.     public Set<Order> getOrders() {  
33.         return orders;  
34.     }  
35.   
36.     public void setOrders(Set<Order> orders) {  
37.         this.orders = orders;  
38.     }  
39.   
40. }  

Order

[java]  view plain  copy

1. package cn.test.hibernate3.demo2;  
2.   
3. /** 
4.  * 订单的实体 
5.  *  
6.  */  
7. public class Order {  
8.     private Integer oid;  
9.     private String addr;  
10.     // 订单属于某一个客户.放置一个客户的对象  
11.     private Customer customer;  
12.   
13.     public Integer getOid() {  
14.         return oid;  
15.     }  
16.   
17.     public void setOid(Integer oid) {  
18.         this.oid = oid;  
19.     }  
20.   
21.     public String getAddr() {  
22.         return addr;  
23.     }  
24.   
25.     public void setAddr(String addr) {  
26.         this.addr = addr;  
27.     }  
28.   
29.     public Customer getCustomer() {  
30.         return customer;  
31.     }  
32.   
33.     public void setCustomer(Customer customer) {  
34.         this.customer = customer;  
35.     }  
36.   
37. }  

Customer.hbm.xml

[html]  view plain  copy

1. <?xml version="1.0" encoding="UTF-8"?>  
2. <!DOCTYPE hibernate-mapping PUBLIC   
3.     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"  
4.     "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">  
5. <hibernate-mapping>  
6.     <class name="cn.test.hibernate3.demo2.Customer" table="customer">  
7.         <!-- 配置唯一标识 -->  
8.         <id name="cid" column="cid">  
9.             <generator class="native" />  
10.         </id>  
11.         <!-- 配置普通属性 -->  
12.         <property name="cname" column="cname" length="20" />  
13.   
14.         <!-- 建立映射 -->  
15.         <!-- 配置一个集合<set>的name Customer对象中的关联对象的属性名称 -->  
16.         <set name="orders" cascade="save-update,delete" inverse="true">  
17.             <!-- <key>标签中的column:用来描述一对多多的一方的外键的名称 -->  
18.             <key column="cno"></key>  
19.             <!-- 配置一个<one-to-many>标签中的class属性:订单的类的全路径 -->  
20.             <one-to-many class="cn.test.hibernate3.demo2.Order" />  
21.         </set>  
22.     </class>  
23. </hibernate-mapping>    

Order.hbm.xml

[html]  view plain  copy

1. <?xml version="1.0" encoding="UTF-8"?>  
2. <!DOCTYPE hibernate-mapping PUBLIC   
3.     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"  
4.     "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">  
5. <hibernate-mapping>  
6.     <!-- 注意：默认情况下 生成的表名和类名相同,但是当涉及到数据库的关键字时，必须指定非关键字的表名 -->  
7.     <class name="cn.test.hibernate3.demo2.Order" table="orders">  
8.         <!-- 配置唯一标识 -->  
9.         <id name="oid" column="oid">  
10.             <generator class="native" />  
11.         </id>  
12.         <!-- 配置普通属性 -->  
13.         <property name="addr" column="addr" length="50" />  
14.         <!-- 配置映射 -->  
15.         <!-- <many-to-one>标签 name :关联对象的属性的名称 column :表中的外键名称 class :关联对象类的全路径 -->  
16.         <many-to-one name="customer" column="cno" cascade="save-update,delete"  
17.             class="cn.test.hibernate3.demo2.Customer" />  
18.     </class>  
19. </hibernate-mapping>      

HibernateTest2

[java]  view plain  copy

1. package cn.test.hibernate3.demo2;  
2.   
3. import org.hibernate.Session;  
4. import org.hibernate.Transaction;  
5. import org.junit.Test;  
6.   
7. import cn.test.hibernate3.demo2.Customer;  
8. import cn.test.hibernate3.demo2.Order;  
9. import cn.test.hibernate3.utils.HibernateUtils;  
10.   
11. /** 
12.  * 一对多测试 为防止干扰,每次测试之前drop掉数据库所有表 在测试删除操作时,drop全部表后,再运行demo1 重新在数据库生成数据 
13.  */  
14. public class HibernateTest2 {  
15.     @Test  
16.     // 双方都不配置级联的情况下  
17.     // 向客户表中插入一个客户,在订单表中插入两个订单  
18.     public void demo1() {  
19.         Session session = HibernateUtils.openSession();  
20.         Transaction tx = session.beginTransaction();  
21.   
22.         // 定义一个客户  
23.         Customer customer = new Customer();  
24.         customer.setCname("郭浩");  
25.   
26.         // 定义两个订单  
27.         Order order1 = new Order();  
28.         order1.setAddr("西三旗中腾");  
29.   
30.         Order order2 = new Order();  
31.         order2.setAddr("西三旗金燕龙");  
32.   
33.         // 建立关系  
34.         order1.setCustomer(customer);  
35.         order2.setCustomer(customer);  
36.   
37.         customer.getOrders().add(order1);  
38.         customer.getOrders().add(order2);  
39.   
40.         session.save(customer);  
41.         session.save(order1);  
42.         session.save(order2);  
43.   
44.         tx.commit();  
45.         session.close();  
46.     }  
47.   
48.     @Test  
49.     // 保存客户和订单的时候,是否可以只保存其中一方？  
50.     // 会报异常：一个持久态的对象关联了一个瞬时态的对象  
51.     // org.hibernate.TransientObjectException: object references an unsaved  
52.     // transient instance - save the transient instance before flushing:  
53.     // cn.test.hibernate3.demo2.Order  
54.     public void demo2() {  
55.         Session session = HibernateUtils.openSession();  
56.         Transaction tx = session.beginTransaction();  
57.   
58.         // 定义客户  
59.         Customer customer = new Customer();  
60.         customer.setCname("李小龙");  
61.   
62.         // 定义订单  
63.         Order order = new Order();  
64.         order.setAddr("五道口");  
65.   
66.         order.setCustomer(customer);  
67.         customer.getOrders().add(order);  
68.   
69.         // 保存的时候只保存一方  
70.         session.save(customer);  
71.   
72.         tx.commit();  
73.         session.close();  
74.     }  
75.   
76.     @Test  
77.     // 保存客户级联保存订单—— 一方设置级联多方  
78.     // <set>集合时客户的关联订单对象的集合.所以在Customer.hbm.xml中<set>上配置一个属性:cascade="save-update"  
79.     public void demo3() {  
80.         Session session = HibernateUtils.openSession();  
81.         Transaction tx = session.beginTransaction();  
82.   
83.         // 定义客户:  
84.         Customer customer = new Customer();  
85.         customer.setCname("郭浩");  
86.   
87.         // 定义订单:  
88.         Order order = new Order();  
89.         order.setAddr("西三旗中腾建华");  
90.         order.setCustomer(customer);  
91.   
92.         customer.getOrders().add(order);  
93.   
94.         // 保存的时候只保存一方:  
95.         session.save(customer);  
96.   
97.         tx.commit();  
98.         session.close();  
99.     }  
100.   
101.     @Test  
102.     // 保存订单级联保存客户——在多方设置级联保存一方  
103.     // 在Order.hbm.xml中<many-to-one>配置cascade属性:级联保存  
104.     public void demo4() {  
105.         Session session = HibernateUtils.openSession();  
106.         Transaction tx = session.beginTransaction();  
107.         // 定义客户:  
108.         Customer customer = new Customer();  
109.         customer.setCname("郭浩");  
110.   
111.         // 定义订单:  
112.         Order order = new Order();  
113.         order.setAddr("西三旗中腾建华");  
114.         order.setCustomer(customer);  
115.   
116.         customer.getOrders().add(order);  
117.   
118.         // 保存的时候只保存一方:  
119.         session.save(order);  
120.   
121.         tx.commit();  
122.         session.close();  
123.     }  
124.   
125.     @Test  
126.     // 测试对象的导航关系——目前是双向级联保存或更新关系  
127.     public void demo5() {  
128.         Session session = HibernateUtils.openSession();  
129.         Transaction tx = session.beginTransaction();  
130.   
131.         // 定义一个客户  
132.         Customer customer = new Customer();  
133.         customer.setCname("武藤兰");  
134.   
135.         // 定义三个订单  
136.         Order order1 = new Order();  
137.         order1.setAddr("西三旗");  
138.   
139.         Order order2 = new Order();  
140.         order2.setAddr("上地");  
141.   
142.         Order order3 = new Order();  
143.         order3.setAddr("五道口");  
144.   
145.         order1.setCustomer(customer);  
146.   
147.         customer.getOrders().add(order2);  
148.         customer.getOrders().add(order3);  
149.   
150.         // session.save(order1); // 共发送4条insert语句  
151.         // session.save(customer);// 共发送3条insert语句  
152.         session.save(order2); // 共发送1条insert语句  
153.         tx.commit();  
154.         session.close();  
155.     }  
156.   
157.     @Test  
158.     // 删除一个客户  
159.     // 默认情况下(即都不配置级联删除的情况下),将外键置为null,删除数据记录  
160.     // 执行完毕后发现数据库中OID为1的customer被删除，customer有关的所有订单都没有被删除,但是这些订单指向被删除customer主键的外键都被置为null  
161.     public void demo6() {  
162.         Session session = HibernateUtils.openSession();  
163.         Transaction tx = session.beginTransaction();  
164.   
165.         // 删除方式有两种  
166.         // 但当涉及到对象关联关系时,只使用先查询再删除的情况  
167.         Customer customer = (Customer) session.get(Customer.class, 1);  
168.         session.delete(customer);  
169.   
170.         tx.commit();  
171.         session.close();  
172.     }  
173.   
174.     @Test  
175.     // 级联删除:删除客户的时候级联删除订单  
176.     // 在Customer.hbm.xml的<set>标签上配置级联删除的属性cascade="delete"  
177.     public void demo7() {  
178.         Session session = HibernateUtils.openSession();  
179.         Transaction tx = session.beginTransaction();  
180.   
181.         // 级联删除:先查询再删除的方式  
182.         Customer customer = (Customer) session.get(Customer.class, 1);  
183.         session.delete(customer);  
184.   
185.         tx.commit();  
186.         session.close();  
187.     }  
188.   
189.     @Test  
190.     // 级联删除:删除订单的时候,级联删除客户  
191.     // 在Order.hbm.xml的<many-to-one>标签上设置级联删除属性cascade="delete"  
192.     public void demo8() {  
193.         Session session = HibernateUtils.openSession();  
194.         Transaction tx = session.beginTransaction();  
195.   
196.         Order order = (Order) session.get(Order.class, 1);  
197.         session.delete(order);  
198.   
199.         tx.commit();  
200.         session.close();  
201.     }  
202.   
203.     @Test  
204.     // 孤儿删除  
205.     // 在Customer.hbm.xml中<set>上配置属性cascade="delete-orphan"  
206.     // 如果默认情况下  
207.     // 即不配置级联孤儿删除，一的一方(Customer)从集合中移除了若干的多的一方，并不会删除被移除的对象，只是将指向它的外键置为null而已  
208.     // 一旦在对应集合上配置了级联孤儿删除，当从集合中移除对象时，外键置为了null Hibernate会查找外键为null的多的一方 并将其删除  
209.     public void demo9() {  
210.         Session session = HibernateUtils.openSession();  
211.         Transaction tx = session.beginTransaction();  
212.   
213.         // 让1号客户和1号订单解除关系  
214.         Customer customer = (Customer) session.get(Customer.class, 1);  
215.   
216.         Order order = (Order) session.get(Order.class, 1);  
217.   
218.         customer.getOrders().remove(order);  
219.   
220.         tx.commit();  
221.         session.close();  
222.     }  
223.   
224.     @Test  
225.     // 双向维护:自动更新数据库，产生多余的SQL  
226.     // 双方默认都有外键的维护能力.必须让其中的一方放弃外键的维护权(一般的情况下都是一的一方放弃)  
227.     // Hibernate: update orders set addr=?, cno=? where oid=?  
228.     // Hibernate: update orders set cno=? where oid=?  
229.     public void demo10() {  
230.         Session session = HibernateUtils.openSession();  
231.         Transaction tx = session.beginTransaction();  
232.   
233.         // 让1号客户和1号订单解除关系  
234.         Customer customer = (Customer) session.get(Customer.class, 1);  
235.   
236.         Order order = (Order) session.get(Order.class, 2);  
237.   
238.         customer.getOrders().add(order);  
239.         order.setCustomer(customer);  
240.   
241.         tx.commit();  
242.         session.close();  
243.     }  
244.   
245.     @Test  
246.     // 区分cascade和inverse  
247.     // 在Customer.hbm.xml中的<set>上配置cascade="save-update" inverse="true"  
248.     public void demo11() {  
249.         Session session = HibernateUtils.openSession();  
250.         Transaction tx = session.beginTransaction();  
251.   
252.         Customer customer = new Customer();  
253.         customer.setCname("张三");  
254.   
255.         Order order = new Order();  
256.         order.setAddr("西三旗");  
257.   
258.         customer.getOrders().add(order);  
259.         // 客户是否存到数据库:存  
260.         // 订单是否存到数据库:存 cascade="save-update".外键是null.  
261.         session.save(customer);  
262.   
263.         tx.commit();  
264.         session.close();  
265.     }  
266.   
267. }  

Course

[java]  view plain  copy

1. package cn.test.hibernate3.demo3;  
2. /** 
3.  * 课程的实体类 
4.  */  
5. import java.util.HashSet;  
6. import java.util.Set;  
7.   
8. public class Course {  
9.     private Integer cid;  
10.     private String cname;  
11.     // 一个课程被多个学生选择  
12.     private Set<Student> students = new HashSet<Student>();  
13.   
14.     public Integer getCid() {  
15.         return cid;  
16.     }  
17.   
18.     public void setCid(Integer cid) {  
19.         this.cid = cid;  
20.     }  
21.   
22.     public String getCname() {  
23.         return cname;  
24.     }  
25.   
26.     public void setCname(String cname) {  
27.         this.cname = cname;  
28.     }  
29.   
30.     public Set<Student> getStudents() {  
31.         return students;  
32.     }  
33.   
34.     public void setStudents(Set<Student> students) {  
35.         this.students = students;  
36.     }  
37.   
38. }  

Student

[java]  view plain  copy

1. package cn.test.hibernate3.demo3;  
2.   
3. import java.util.HashSet;  
4. import java.util.Set;  
5.   
6. /** 
7.  * 学生的实体类 
8.  *  
9.  */  
10. public class Student {  
11.     private Integer sid;  
12.     private String sname;  
13.     // 一个学生选择多门课程  
14.     private Set<Course> courses = new HashSet<Course>();  
15.   
16.     public Integer getSid() {  
17.         return sid;  
18.     }  
19.   
20.     public void setSid(Integer sid) {  
21.         this.sid = sid;  
22.     }  
23.   
24.     public String getSname() {  
25.         return sname;  
26.     }  
27.   
28.     public void setSname(String sname) {  
29.         this.sname = sname;  
30.     }  
31.   
32.     public Set<Course> getCourses() {  
33.         return courses;  
34.     }  
35.   
36.     public void setCourses(Set<Course> courses) {  
37.         this.courses = courses;  
38.     }  
39.   
40. }  

Course.hbm.xml

[html]  view plain  copy

1. <?xml version="1.0" encoding="UTF-8"?>  
2. <!DOCTYPE hibernate-mapping PUBLIC   
3.     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"  
4.     "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">  
5. <hibernate-mapping>  
6.     <class name="cn.test.hibernate3.demo3.Course" table="course">  
7.         <!-- 配置唯一标识 -->  
8.         <id name="cid" column="cid">  
9.             <generator class="native" />  
10.         </id>  
11.         <!-- 配置普通属性 -->  
12.         <property name="cname" column="cname" length="20" />  
13.         <!-- 配置与学生关联映射 -->  
14.         <!-- <set>中name:对应当前类中的学生集合的名称 table:中间表名称 -->  
15.         <set name="students" table="stu_cour" inverse="true">  
16.             <!-- <key>中column:当前类在中间表中外键 -->  
17.             <key column="cno"></key>  
18.             <!-- <many-to-many>中class:另一方的类全路径 column:另一方在中间表中的外键名称 -->  
19.             <many-to-many class="cn.test.hibernate3.demo3.Student"  
20.                 column="sno" />  
21.         </set>  
22.   
23.     </class>  
24.   
25. </hibernate-mapping>      

Student.hbm.xml

[html]  view plain  copy

1. <?xml version="1.0" encoding="UTF-8"?>  
2. <!DOCTYPE hibernate-mapping PUBLIC   
3.     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"  
4.     "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">  
5. <hibernate-mapping>  
6.     <class name="cn.test.hibernate3.demo3.Student" table="student">  
7.         <!-- 配置唯一标识 -->  
8.         <id name="sid" column="sid">  
9.             <generator class="native" />  
10.         </id>  
11.         <!-- 配置普通属性 -->  
12.         <property name="sname" column="sname" />  
13.   
14.         <!-- 配置关联映射 -->  
15.         <!-- <set>标签name属性:对应学生中的课程集合的名称 table:中间表的名称 -->  
16.         <set name="courses" table="stu_cour" cascade="save-update">  
17.             <!-- <key>中column: 当前类在中间表中的外键 -->  
18.             <key column="sno"></key>  
19.             <!-- <many-to-many>中class:另一方类的全路径 column:另一方在中间表中外键名称 -->  
20.             <many-to-many class="cn.test.hibernate3.demo3.Course"  
21.                 column="cno" />  
22.         </set>  
23.     </class>  
24. </hibernate-mapping>  
25.       

HibernateTest3

[java]  view plain  copy

1. package cn.test.hibernate3.demo3;  
2.   
3. import org.hibernate.Session;  
4. import org.hibernate.Transaction;  
5. import org.junit.Test;  
6.   
7. import cn.test.hibernate3.demo3.Course;  
8. import cn.test.hibernate3.demo3.Student;  
9. import cn.test.hibernate3.utils.HibernateUtils;  
10.   
11. public class HibernateTest3 {  
12.     @Test  
13.     // 多对多的学生退选.  
14.     // Hibernate: delete from stu_cour where sno=? and cno=?  
15.     // 这种从集合中移除另一方在多对多中可行的 即使不配置级联删除也会直接从中间表中删除对应的记录  
16.     // 但是如果不配置级联删除 就直接session.delete(student)去删除有课程关联的学生 是会抛出异常的因为中间表中还有一个外键约束  
17.     public void demo4() {  
18.         Session session = HibernateUtils.openSession();  
19.         Transaction tx = session.beginTransaction();  
20.   
21.         // 查询一号学生  
22.         Student student = (Student) session.get(Student.class, 1);  
23.         Course course = (Course) session.get(Course.class, 2);  
24.         student.getCourses().remove(course);  
25.   
26.         tx.commit();  
27.         session.close();  
28.     }  
29.   
30.     @Test  
31.     // 级联删除:在多对多中很少使用.  
32.     // 删除:删除学生同时删除学生关联选课  
33.     public void demo3() {  
34.         Session session = HibernateUtils.openSession();  
35.         Transaction tx = session.beginTransaction();  
36.   
37.         Student student = (Student) session.get(Student.class, 3);  
38.         session.delete(student);  
39.   
40.         tx.commit();  
41.         session.close();  
42.     }  
43.   
44.     @Test  
45.     // 级联操作:级联保存:保存学生关联课程  
46.     // 在Student.hbm.xml中配置<set>上 cascade="save-update"  
47.     public void demo2() {  
48.         Session session = HibernateUtils.openSession();  
49.         Transaction tx = session.beginTransaction();  
50.   
51.         // 创建学生:  
52.         Student student1 = new Student();  
53.         student1.setSname("王五");  
54.   
55.         // 创建课程:  
56.         Course course1 = new Course();  
57.         course1.setCname("PHP语言");  
58.   
59.         student1.getCourses().add(course1);  
60.         course1.getStudents().add(student1);  
61.   
62.         session.save(student1);  
63.   
64.         tx.commit();  
65.         session.close();  
66.     }  
67.   
68.     @Test  
69.     // 保存学生和课程.为学生选择一些课程:  
70.     // 如果没有任何一方放弃主键的维护，不只是多余SQL的问题 会抛出异常，因为往中间表内插入两条相同的联合主键是不允许的  
71.     public void demo1() {  
72.         Session session = HibernateUtils.openSession();  
73.         Transaction tx = session.beginTransaction();  
74.   
75.         // 创建学生:  
76.         Student student1 = new Student();  
77.         student1.setSname("张三");  
78.         Student student2 = new Student();  
79.         student2.setSname("李四");  
80.   
81.         // 创建课程:  
82.         Course course1 = new Course();  
83.         course1.setCname("Java语言");  
84.         Course course2 = new Course();  
85.         course2.setCname("Android语言");  
86.   
87.         // 张三选1号和2号课  
88.         student1.getCourses().add(course1);  
89.         student1.getCourses().add(course2);  
90.   
91.         course1.getStudents().add(student1);  
92.         course2.getStudents().add(student1);  
93.   
94.         student2.getCourses().add(course1);  
95.         course1.getStudents().add(student2);  
96.   
97.         // 执行保存:  
98.         session.save(student1);  
99.         session.save(student2);  
100.         session.save(course1);  
101.         session.save(course2);  
102.   
103.         tx.commit();  
104.         session.close();  
105.     }  
106. }  

hibernate.cfg.xml

[html]  view plain  copy

1. <?xml version="1.0" encoding="UTF-8"?>  
2. <!DOCTYPE hibernate-configuration PUBLIC  
3.     "-//Hibernate/Hibernate Configuration DTD 3.0//EN"  
4.     "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">  
5.   
6. <hibernate-configuration>  
7. <session-factory>  
8.     <!-- 必须去配置的属性 -->  
9.     <!-- 配置数据库连接的基本信息: -->  
10.     <property name="hibernate.connection.driver_class">  
11.         com.mysql.jdbc.Driver  
12.     </property>  
13.     <property name="hibernate.connection.url">  
14.         jdbc:mysql:///hibernate3_day02  
15.     </property>  
16.     <property name="hibernate.connection.username">root</property>  
17.     <property name="hibernate.connection.password">root</property>  
18.     <!-- Hibernate的方言 -->  
19.     <!-- 生成底层SQL不同的 -->  
20.     <property name="hibernate.dialect">  
21.         org.hibernate.dialect.MySQLDialect  
22.     </property>  
23.   
24.     <!-- 可选的属性 -->  
25.     <!-- 显示SQL -->  
26.     <property name="hibernate.show_sql">true</property>  
27.     <!-- 格式化SQL -->  
28.     <property name="hibernate.format_sql">true</property>  
29.   
30.     <property name="hibernate.connection.autocommit">false</property>  
31.     <!-- hbm:映射 to DDL: create drop alter -->  
32.     <property name="hibernate.hbm2ddl.auto">update</property>  
33.   
34.     <!-- C3P0连接池设定 -->  
35.     <!-- 使用c3po连接池 配置连接池提供的供应商 -->  
36.     <property name="connection.provider_class">  
37.         org.hibernate.connection.C3P0ConnectionProvider  
38.     </property>  
39.   
40.     <!--在连接池中可用的数据库连接的最少数目 -->  
41.     <property name="c3p0.min_size">5</property>  
42.     <!--在连接池中所有数据库连接的最大数目 -->  
43.     <property name="c3p0.max_size">20</property>  
44.     <!--设定数据库连接的过期时间,以秒为单位, 如果连接池中的某个数据库连接处于空闲状态的时间超过了timeout时间,就会从连接池中清除 -->  
45.     <property name="c3p0.timeout">120</property>  
46.     <!--每3000秒检查所有连接池中的空闲连接 以秒为单位 -->  
47.     <property name="c3p0.idle_test_period">3000</property>  
48.   
49.     <!-- 通知Hibernate加载那些映射文件 -->  
50.     <!-- <mapping resource="cn/test/hibernate3/demo1/Book.hbm.xml" /> -->  
51.     <!-- <mapping resource="cn/test/hibernate3/demo2/Customer.hbm.xml" /> -->  
52.     <!-- <mapping resource="cn/test/hibernate3/demo2/Order.hbm.xml" /> -->  
53.     <mapping resource="cn/test/hibernate3/demo3/Course.hbm.xml" />  
54.     <mapping resource="cn/test/hibernate3/demo3/Student.hbm.xml" />  
55.   
56. </session-factory>  
57. </hibernate-configuration>