Hibernate5-课程笔记6

Hibernate检索优化：

　　检索即查询。为了减轻DB的访问压力，提高检索效率，Hibernate对检索进行了优化。
　　所谓检索优化，指的是对查询语句的执行时机进行了细致、严格的把控：并不是代码中一出现查询语句，马上就在后台调用执行select语句。而是在代码中真正需要时才执行select。即将select的执行进行了最大可能的“延迟”。
　　对对象进行检索的目的是为了将对象加载到内存，让程序使用其数据。所以，对象检索也称为对象加载。根据检索对象的不同，可以将检索优化分为两类：  （1）当前对象检索优化 （2）关联对象检索优化
　　对于不使用优化进行对象检索的过程，称为直接加载；否则称为延迟加载，或懒加载。 延迟加载的底层实现，在Hibernate3.3版本之前使用的是CGLIB生成代理实现的，而3.3版本以后是由javassist代理实现的。若实体类使用final修饰，将无法生成CGLIB代理，即对于3.3版本之前的Hibernate将无法实现延迟加载。考虑到对老版本代码的兼容问题，实体类最好不要使用final修饰。　　

　　（1）当前对象检索优化：

　　　　对于当前对象进行检索加载，Session中提供了两个方法：get()与load()。  默认情况下，get()为直接加载，而load()为延迟加载。
　　　　get()方法的直接加载指，当代码中出现get()时，后台马上会调用执行select语句，将对象直接加载到内存。
　　　　load()方法的延迟加载指，当代码中出现load()时，后台并不会马上调用执行select。只有当代码中真正在访问除了主键id属性以外的其它属性时，才会真正执行select语句，即此时才会将对象真正加载到内存。

　　　　load()方法默认情况下采用延迟加载策略，但也是可以改变的，可以改为直接加载。在该类映射文件的<class/>标签中有个属性lazy，其默认值为true，即采用延迟加载策略。将其值修改为false，load()的执行也将采用直接加载。

　　（2）关联对象检索优化：

　　　　对于关联对象的检索，也可进行延迟加载的优化。采用何种优化策略，要依据映射文件的配置。映射文件中对于关联对象检索的优化配置属性有两个：lazy、fetch。 
　　　　lazy与fetch各具有若干值，它们不同值的组合，表示不同的对象加载策略。  根据这两个属性配置位置的不同，又分为两种：  （1）多端配置优化  （2）单端配置优化

　　　　（1）多端加载优化（在一方对象的映射文件中配置属性）：

 <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE hibernate-mapping PUBLIC
     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
     "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

 <hibernate-mapping package="com.tongji.beans">
     <class name="Country">
         <id name="cid">
             <generator class="native"/>
         </id>
         <property name="cname"/>
         <!-- 左外连接查询，不存在延迟加载问题，也就不存在多端加载优化问题 ，所以不用lazy-->
         <!-- <set name="ministers" cascade="all" fetch="join"> -->
         <!-- 普通查询（两表分别查询），不使用延迟加载，则查找当前对象的时候，不管关联对象是否用到，都会一起加载 -->
         <!-- <set name="ministers" cascade="all" fetch="select" lazy="false"> -->
         <!-- 普通查询，使用延迟加载，则查找当前对象的时候，不加载关联对象，直到用到关联对象的时候，才会加载关联对象 -->
         <!-- <set name="ministers" cascade="all" fetch="select" lazy="true"> -->
         <!-- 普通查询，特别延迟，则查找当前对象的时候，不加载关联对象，并且用到关联对象的时候，能用聚合查询的时候，就不做详情查询 -->
         <!-- <set name="ministers" cascade="all" fetch="select" lazy="extra"> -->
         <!-- 补充:子查询，效果同普通查询，其实Hibernate5不支持该策略，但为了兼容以前的版本，对subselect进行了保留 -->
         <!-- <set name="ministers" cascade="all" fetch="subselect" lazy="extra"> -->
         <!-- 默认使用，fetch="select" lazy="true"这种格式 -->
         <set name="ministers" cascade="save-update">
             <key column="countryId"/>
             <one-to-many class="Minister"/>
         </set>
     </class>
 </hibernate-mapping>

　　　　测试代码：

 @Test
 public void test01() {
     //1. 获取Session
     Session session = HbnUtils.getSession();
     try {
         //2. 开启事务
         session.beginTransaction();
         //3. 操作
         Country country = session.get(Country.class, 1);
         Set<Minister> ministers = country.getMinisters();
         //集合大小的输出
         System.out.println("ministers.size() = " + ministers.size());
         //集合详情的输出
         System.out.println(ministers);
         //4. 事务提交
         session.getTransaction().commit();
     } catch (Exception e) {
         e.printStackTrace();
         //5. 事务回滚
         session.getTransaction().rollback();
     }
 }

　　　　（2）单端加载优化（在多方对象的映射文件配置属性）：

 <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE hibernate-mapping PUBLIC
     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
     "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

 <hibernate-mapping package="com.tongji.beans">
     <class name="Minister">
         <id name="mid">
             <generator class="native"/>
         </id>
         <property name="mname"/>
         <!-- 关联属性名 -->
         <!-- 左外连接查询，同多端加载优化 -->
         <!-- <many-to-one name="country" cascade="save-update"
             class="Country" column="countryId" fetch="join"/> -->
         <!-- 普通查询之直接加载，同多端加载优化 -->
         <!-- <many-to-one name="country" cascade="save-update"
             class="Country" column="countryId" fetch="select" lazy="false"/> -->
         <!-- 普通查询，是否延迟加载，由关联对象的lazy值决定-->
         <many-to-one name="country" cascade="save-update"
             class="Country" column="countryId" fetch="select" lazy="proxy"/>
         <!-- 补充:no-proxy和proxy基本相同，但是会对字节码进行加强 -->
         <!-- <many-to-one name="country" cascade="save-update"
             class="Country" column="countryId" fetch="select" lazy="no-proxy"/> -->
     </class>
 </hibernate-mapping>

 <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE hibernate-mapping PUBLIC
     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
     "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

 <hibernate-mapping package="com.tongji.beans">
     <!-- 单端加载优化，之普通查询，直接加载-->
     <!-- <class name="Country" lazy="false"> -->
     <!-- 单端加载优化，之普通查询，延迟加载 ，默认-->
     <class name="Country" lazy="true">
         <id name="cid">
             <generator class="native"/>
         </id>
         <property name="cname"/>
         <set name="ministers" cascade="all">
             <key column="countryId"/>
             <one-to-many class="Minister"/>
         </set>
     </class>
 </hibernate-mapping>

　　　　测试代码：

 @Test
 public void test01() {
     //1. 获取Session
     Session session = HbnUtils.getSession();
     try {
         //2. 开启事务
         session.beginTransaction();
         //3. 操作
         Minister minister = session.get(Minister.class, 2);
         Country country = minister.getCountry();

         System.out.println("country.id = " + country.getCid());
         System.out.println("country.name = " + country.getCname());
         //4. 事务提交
         session.getTransaction().commit();
     } catch (Exception e) {
         e.printStackTrace();
         //5. 事务回滚
         session.getTransaction().rollback();
     }
 }