Hibernate 抓取策略fetch-1 (select join subselect)

原文 :http://4045060.blog.51cto.com/4035060/1088025

部分参考:http://www.cnblogs.com/rongxh7/archive/2010/05/12/1733088.html

Hibernate3 定义了如下几种抓取策略:

连接抓取（Join fetching） - Hibernate通过 在SELECT语句使用OUTER JOIN 
（外连接）来 获得对象的关联实例或者关联集合.

---

查询抓取（Select fetching） - 另外发送一条 SELECT 语句抓取当前对象的关联实 
体或集合。除非你显式的指定lazy="false"禁止 延迟抓取（lazy fetching），否 
则只有当你真正访问关联关系的时候，才会执行第二条select语句.

　　 备注: 查询抓取, 这种策略是在集合抓取的时候的默认策略, 即如果集合需要初始化, 那么会重新发出一条 SQL 语句进行查询;

        这是集合默认的抓取策略, 也就是我们常会出现N+1次查询的查询策略;

 

---

子查询抓取（Subselect fetching） - 另外发送一条SELECT 语句抓取在前面查询到 
（或者抓取到）的所有实体对象的关联集合。除非你显式的指定lazy="false" 禁止延迟 
抓取（lazy fetching），否则只有当你真正访问关联关系的时候，才会执行第二条 
select语句

---

批量抓取（Batch fetching） - 对查询抓取的优化方案， 通过指定一个主键或外键 
列表，Hibernate使用单条SELECT语句获取一批对象实例或集合

 

一、hibernate抓取策略（单端代理的批量抓取fetch=select(默认）/join）

 1）保持默认，同fetch="select" 

<many-to-one name="group" column="group_id" fetch="select" />

另外发送一条select语句抓取当前对象关联实体或集合.

测试代码

        Session session = null;
        try {
            session = HibernateUtils.getSession();
            /**
             * 只读操作,不使用事务也可进行.Hibernate建议任何操作都使用事务.
             */
            User u = (User) session.load(User.class,"402881e6466ae95a01466ae95c4d0004");// 加载User
            System.out.println("执行了session.load方法");
            System.out.println("[value]" + u.getName());
            System.out.println("[value]" + u.getGroup().getName());
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (session != null) {
                // 关闭session
                session.close();
            }
        }

 执行效果

执行了session.load方法
Hibernate: 
    select
        user0_.id as id0_0_,
        user0_.name as name0_0_,
        user0_.password as password0_0_,
        user0_.createTime as createTime0_0_,
        user0_.updateTime as updateTime0_0_,
        user0_.group_id as group6_0_0_ 
    from
        TEST_User user0_ 
    where
        user0_.id=?
[value]james
Hibernate: 
    select
        group0_.id as id1_0_,
        group0_.name as name1_0_ 
    from
        TEST_Group group0_ 
    where
        group0_.id=?
[value]集团2

2）设置fetch="join"

 <many-to-one name="group" column="group_id" fetch="join" />

hibernate会通过select语句使用外连接来加载其关联实体或集合. 此时lazy会失效.  执行结果：一条join语句 

测试代码同上

执行效果

执行了session.load方法
Hibernate: 
    select
        user0_.id as id0_1_,
        user0_.name as name0_1_,
        user0_.password as password0_1_,
        user0_.createTime as createTime0_1_,
        user0_.updateTime as updateTime0_1_,
        user0_.group_id as group6_0_1_,
        group1_.id as id1_0_,
        group1_.name as name1_0_ 
    from
        TEST_User user0_ 
    left outer join
        TEST_Group group1_ 
            on user0_.group_id=group1_.id 
    where
        user0_.id=?
[value]james
[value]集团2

 二、hibernate抓取策略（集合代理的批量抓取，fetch=select（默认）/join/subselect）

1)保持默认，同fetch="select",如  

<set name="users" fetch="select" >
   <key column="group_id"/>
   <one-to-many class="com.test.entity.User" />
  </set>fetch="select",

另外发送一条select语句抓取当前对象关联实体或集合
测试结果：2条独立的查询语句

 测试代码

Session session = null;
        try {
            session = HibernateUtils.getSession();
            /**
             * 只读操作,不使用事务也可进行.Hibernate建议任何操作都使用事务.
             */
            Group g = (Group) session.load(Group.class,"402881e6466ae95a01466ae95c460001");// 加载Group
            System.out.println("执行了session.load方法");
            System.out.println("[value]" + g.getName());
            Set<User> us = g.getUsers();
            for (Iterator iter = us.iterator(); iter.hasNext();) {
                User u = (User) iter.next();
                System.out.println("[value]" + u.getName());
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (session != null) {
                // 关闭session
                session.close();
            }
        }

执行效果

执行了session.load方法
Hibernate: 
    select
        group0_.id as id1_0_,
        group0_.name as name1_0_ 
    from
        TEST_Group group0_ 
    where
        group0_.id=?
[value]集团2
Hibernate: 
    select
        users0_.group_id as group6_1_,
        users0_.id as id1_,
        users0_.id as id0_0_,
        users0_.name as name0_0_,
        users0_.password as password0_0_,
        users0_.createTime as createTime0_0_,
        users0_.updateTime as updateTime0_0_,
        users0_.group_id as group6_0_0_ 
    from
        TEST_User users0_ 
    where
        users0_.group_id=?
[value]james
[value]kobe
[value]jordan

 2)设置fetch="join"

 如:

  <set name="users" fetch="join" >
   <key column="group_id"/>
   <one-to-many class="com.test.entity.User" />
  </set>

 fetch="join",hibernate会通过select语句使用外连接来加载其关联实体或集合. 此时lazy会失效
测试结果：1条独立的join查询语句

测试代码: 同上例

执行效果:

Hibernate: 
    select
        group0_.id as id1_1_,
        group0_.name as name1_1_,
        users1_.group_id as group6_3_,
        users1_.id as id3_,
        users1_.id as id0_0_,
        users1_.name as name0_0_,
        users1_.password as password0_0_,
        users1_.createTime as createTime0_0_,
        users1_.updateTime as updateTime0_0_,
        users1_.group_id as group6_0_0_ 
    from
        TEST_Group group0_ 
    left outer join
        TEST_User users1_ 
            on group0_.id=users1_.group_id 
    where
        group0_.id=?
[value]集团2
[value]james
[value]jordan
[value]kobe

 3)设置fetch="subselect"

   <set name="users" fetch="subselect" >
   <key column="group_id"/>
   <one-to-many class="com.test.entity.User" />
  </set>

 测试结果: fetch="subselect",另外发送一条select语句抓取在前面查询到的所有实体对象的关联集合.

测试代码: 同上例

执行效果:

执行了session.load方法
Hibernate: 
    select
        group0_.id as id1_0_,
        group0_.name as name1_0_ 
    from
        TEST_Group group0_ 
    where
        group0_.id=?
[value]集团2
Hibernate: 
    select
        users0_.group_id as group6_1_,
        users0_.id as id1_,
        users0_.id as id0_0_,
        users0_.name as name0_0_,
        users0_.password as password0_0_,
        users0_.createTime as createTime0_0_,
        users0_.updateTime as updateTime0_0_,
        users0_.group_id as group6_0_0_ 
    from
        TEST_User users0_ 
    where
        users0_.group_id=?
[value]kobe
[value]jordan
[value]james

 为更好体现subselect的效果用例如下: 通过调节获取符合条件的Group集合,访问其中一个Group的关联集合User

测试代码:

List<Group> gs=session.createQuery(" from Group g where g.name like'集团%'").list();
            Group g0=gs.get(0);
            System.out.println("[value]" + g0.getName());
            System.out.println("[value]" + g0.getUsers().size());

执行效果: 在之前查询语句的基础上,发出子查询.

Hibernate: 
    select
        group0_.id as id1_,
        group0_.name as name1_ 
    from
        TEST_Group group0_ 
    where
        group0_.name like '集团%'
[value]集团2
Hibernate: 
    select
        users0_.group_id as group6_1_,
        users0_.id as id1_,
        users0_.id as id0_0_,
        users0_.name as name0_0_,
        users0_.password as password0_0_,
        users0_.createTime as createTime0_0_,
        users0_.updateTime as updateTime0_0_,
        users0_.group_id as group6_0_0_ 
    from
        TEST_User users0_ 
    where
        users0_.group_id in (
            select
                group0_.id 
            from
                TEST_Group group0_ 
            where
                group0_.name like '集团%'
        )
[value]3

若将fetch="subselect"的配置去掉.

则执行效果如下 , 用了默认的select fetch查询方式

Hibernate: 
    select
        group0_.id as id1_,
        group0_.name as name1_ 
    from
        TEST_Group group0_ 
    where
        group0_.name like '集团%'
[value]集团2
Hibernate: 
    select
        users0_.group_id as group6_1_,
        users0_.id as id1_,
        users0_.id as id0_0_,
        users0_.name as name0_0_,
        users0_.password as password0_0_,
        users0_.createTime as createTime0_0_,
        users0_.updateTime as updateTime0_0_,
        users0_.group_id as group6_0_0_ 
    from
        TEST_User users0_ 
    where
        users0_.group_id=?
[value]3

总结：
 

---

 hibernate抓取策略

1.单端代理的批量抓取 (如Group.getUser().getName()这样）
　1.1 保持默认，同fetch="select",如：<many-to-one name="classes" column="classesid" fetch="select"/>
　　　fetch="select", 有用到lazy, 实际用到关联属性才会发出SQL.(另外发送一条select语句抓取当前对象关联实体或集合)
   1.2设置fetch="join",如：<many-to-one name="classes" column="classesid" fetch="join"/>
  　　fetch="join",hibernate会通过select语句使用外连接来加载其关联实体或集合. 只发出1条SQL.
  　　此时lazy会失效
 

2.集合代理的批量抓取 (如Set<User> us=Group.getUsers();  然后获取集合中User的属性）
　2.1 保持默认，同fetch="select",如：<set name="students" inverse="true" cascade="all" fetch="select">
　　   fetch="select",另外发送一条select语句抓取当前对象关联实体或集合
  2.2  设置fetch="join",如：<set name="students" inverse="true" cascade="all" fetch="join">
　　  fetch="join", 有用到lazy, 实际用到关联属性才会发出SQL.( hibernate会通过select语句使用外连接来加载其关联实体或集合)
　　 此时lazy会失效

  2.3设置fetch="subselect",如：<set name="students" inverse="true" cascade="all" fetch="subselect">
　　 fetch="subselect",另外发送一条select语句抓取在前面查询到的所有实体对象的关联集合
 
3.hibernate批量抓取，Hibernate提供了两种批量抓取方案：类级别和集合级别。 

         类级别的批量查询。如果一个Session中需要载入30个student实例，在student中拥有一个成员变量class，该class执行Class对象。如果lazy=“true”，如果们需要变量整个student集合，每一个student都需要getClass()，hibernate在默认情况下回执行30次select查询语句，得到Class对象。这个时候可以通过在映射文件的Class属性，batch-size。

 

<class name=”Class” batch-size=”15”>….</class>

 

         这样Hibernate将只需要执行两次查询即可：15,15。

         集合级别的批量查询。如果我们需要遍历Class所拥有的所有Student对象，在Session中需要载入30个Class对象，遍历Class集合将会引起30次Select查询，每次查询都会调用getStudents()。如果在Class的映射定义中，允许对Students进行批量抓取，则Hibernate就会预先加载整个集合。

 

<set name=”students” batch-size=”15”>…</set>