传智播客--hibernate关系映射和性能优化（徐培成）

今天学习到了 hibernate 中的关键地方了,对象之间的关系和映射文件的配置和编写.Hibernate的学习主要就是学习映射文件.映射文件是 Java 对象和关系型数据库之间的桥梁.通过配置文件对 Java 对象进行配置就是要映射出表与表之间的关系.听懂很容易,要想用好就不是那么容易的事情了.好好总结一下今天学习到的知识吧.

1.一对多
<set name=“orders”
        cascade=“save-update”>
      <key column=“CUSTOMER_ID” />
      <one-to-many class=“..Order” />
</set>
属性注释:
name:设定待映射持久化类的属性名。
cascade:设定级联操作的程度。
key 子属性:设定与所关联的持久化类对应的标的外键。
one-to-many子属性:设定所关联的持久化类。
总结:
在一对多的时候,属性声明成Set还是List呢?
Set是不容许有重复,插入元素无序.
List是容许有重复,插入元素有序.
用List有重复元素,在插入的时候有插入数据重复提示.所以,要声明成Set.
使用一对多的时候,要慎重,效率很低.
通常在定义集合属性时，直接初始化为一个实现类的实例。 private Set orders = new HashSet(); 可避免空指针异常.
在映射一对多的双向关联关系时，应该在one方把inverse属性设为true，这可以提高性能。
在建立两个对象的关联时，应该同时修改关联两端的相应属性：
   Customer.getOrders().add(order);
   Order.setCustomer(customer);
这样才会使程序更加健壮，提高业务逻辑层的独立性，使业务逻辑层的程序代码不受Hibernate实现类的影响。同理，当删除双向关联的关系时，也应该修 改关联两端的对象的相应属性：
Customer.getOrders().remove(order);
Order.setCustomer(null);

2.多对一
<class name="Order" table="hib_orders" lazy="false">
    <id name="id" column="id" type="integer">
        <generator class="identity" />
    </id>
    <property name="orderNo" column="orderno" type="string" length="15" />
    <property name="price" column="price" type="float" />
    <!-- 映射多对一关联关系 -->
    <many-to-one name="customer" column="cid" class="Customer" cascade="save-update" />
</class>
总结:
就的一对多,从另外一个角度看. 这个关系是经常用到的.
属性中不用private Department depart;这个而用private int pepartid;也是可以的,但这就不能发挥Hibernate的优势了
在维护关系上,常是用这个多的一端来维护,这样和数据库交换的少,可以大大的提高系统的性能.
这里会有一个问题,注意使用数据的位置,涉及到了懒加载的问题.
通过Hibernate.initialize(emp.getDepart());来解决这个问题.这里是强制它查询数据库,给对象进行初始化.

3.一对一
一对一分两种情况
1)外键:多对一的特例,将不能重复设置成真.
<!-- 影射一对一外键关联用many-to-one进行模拟,增加唯一性约束 -->
<many-to-one name="addr" column="aid" class="AddrFk" unique="true" />
<one-to-one name="user" property-ref="addr"/>
2)主键
<!-- 影射一对一主键关联 -->
<one-to-one name="addr" class="AddrPk" />
<class name="AddrPk" table="hib_addrpks" lazy="false">
    <id name="id" column="id" type="integer">
        <generator class="foreign">
            <param name="property">user</param>
        </generator>
    </id>
    <property name="province" column="province" type="string" length="20" />
    <property name="city" column="city" type="string" length="20" />
   
    <one-to-one name="user" class="UserPk" constrained="true"/>
</class>

4.多对多
<!-- 影射多对多关联 -->
<set name="teas" table="hib_tea_stu_links" lazy="false" inverse="true">
    <key column="sid" />
    <many-to-many class="Tea" column="tid" />
</set>
<!-- 影射多对多关联 -->
<set name="stus" table="hib_tea_stu_links" lazy="false">
    <key column="tid" />
    <many-to-many class="Stu" column="sid" />
</set>
总结:
多对多的时候,会产生一个中间表.用来维护表之间的关联关系.
并要明确的指定中间表的名字.

5.session
session的缓存:当session的save()方法持久化一个对象时，该对象被载入缓存，以后即使程序中不再引用该对象，只要缓存不清空，该对象 仍然处于生命周期中。当试图load()对象时，会判断缓存中是否存在该对象，有则返回。
缓存的作用：
尽量减少访问数据库的次数,提高系统的效率.
保证缓存中的对象与数据库中的相关记录保持同步。
当session加载了customer对象后，会为customer对象的值类型的属性复制一份快照。当清理缓存时，通过比较对象的当前属性和快照，来 判断对象的那些属性发生了变化。
Session 清理缓存执行sql语句的顺序:
按照应用程序调用save（）方法的先后顺序，执行所有的对实体进行插入的insert语句。
所有对实体进行更新的update语句。
所有对实体进行删除的delete语句。
所有对集合元素进行删除、更新或插入的sql语句。
执行所有对集合进行插入的insert语句。
按照应用程序调用delete（）方法的先后执行。

6.inverse:
让一的一端, 集合端,放弃更新,放弃维护关系.默认是关闭的.
<set>元素的inverse属性
Hibernate会自动清理缓存中的所有持久化对象，按照持久化对象的改变来同步更新数据库，因此执行了上述的两条更新语句。重复执行多余的sql语句 会影响java性能，解决这也问题的办法是把<set>元素的inverse属性设为true,该属性的默认值是false。
在映射一对多的双向关联关系时，应该在one 方把inverse属性设为true，这可以提高性能。
在建立两个对象的关联时，应该同时修改关联两端的相应属性：
   Customer.getOrders().add(order);
   Order.setCustomer(customer);
这样才会使程序更加健壮，提高业务逻辑层的独立性，使业务逻辑层的程序代码不受Hibernate实现类的影响。同理，当删除双向关联的关系时，也应该修 改关联两端的对象的相应属性：
Customer.getOrders().remove(order);
Order.setCustomer(null);

7.cascade
这个属性要小心设置,否则因为错误的设置对系统数据的破换性很大,不容易恢复.
Customer customer = (Customer) s.load(Customer.class,new Long(2));
Session.delete(customer);
tx.commit();
如果cascade属性取默认值none，不会自动删除和customer关联的其他持久化对象。如果希望删除customer时，自动删除和 customer关联的order对象，可把cascade属性设为delete。
<set name=“orders” cascade=“delete” inverse=“true”>
        <key column=“CUSTOMER_ID” />
        <one-to-many class=“mypack.Order” />
</set>
再运行删除方法的时候，会自动删除order对象.

8.父子关系
就是父方来控制子方的持久化生命周期，子方对象必须和一个父方对象关联。
当customer.hbm.xml 的<set>元素的cascade属性取值为all-delete-orphan,Hibernate会按照如下方式处理customer对 象：
当保存或更新customer对象时，级联保存或更新所有关联的order对象，相当于save-update.
当删除 customer对象时，级联删除所有的order对象，相当于delete。
删除不再和customer对象关联的所有order对象。当关联双方存在父子关系时，就可以把父方的cascade属性设为 all-delete-orphan.

9.这几个方法的不同之处:
commit() 先调用flush方法，然后提交事务。提交事务意味着对数据库操作永久保存下来。
flush()清理,刷出;不提交,就能回滚  和 s.setFlushMode()的设置讲解
refresh()刷新缓存;数据库→缓存
clear()清空缓存内容.

10.hibernate 中java对象的状态
1)持久化对象
位于一个session缓存中，总是被一个session关联。持久化对象和数据库记录相对应。清理缓存时，会根据对象属性变化，同步更新数据库。 save把临时对象转变为持久化对象。load或find或get返回的对象总是持久化状态。find方法返回的list存放的都是持久化对象。 update、save、SaveOrUpdate和Lock方法使游离对象装变为持久化对象。在实际的应用程序中应该避免一个java对象被多个 session实例关联，会导致重复执行sql语句，并且极容易出现一些并发问题。
2)游离对象
不再位于 session的缓存中，游离对象不被session关联。游离对象由持久化转变过来的，因此在数据库中可能还存在与它对应的记录（前提条件是没有其他程 序删除了这条记录）。
3)临时对象 :
刚刚被new出来的对象,还没有和session有任何操作.

11.unsaved- value 和 s.saveOrUpdate()
Hibernate是怎么区分是保存还是更新呢.unsaved-value就是用来区分是不是被保存过.Hibernate中用对象表示符(OID)来 区分对象.

12.s.load()和 s.get()的区别.
load()是在需要数据的时候才访问数据库.
get()是执行了就马上访问数据库.

13.检索策略 lazy的配置
这个很重点,对系统的性能优化和提升有很大的帮助.
一对多和多对多关联的检索策略有:立即检索,延迟检索,批量延迟检索,批量立即检索,迫切左外连接检索

总结:
联合主键不推荐使用,Hibernate中有联合主键,其官方的说法是为了适应已经存在的老系统.
debug 的使用,调试的表达式里不要有表达式.调试进程要有一个进程