Hibernate的关联关系中lazy和fetch的设置

Dear 丶 2022-08-26 14:24 121阅读 0赞

Hibernate的关联关系中lazy和fetch的设置会影响到对数据进行查询时候SQL语句的操作,fetch的设置相对于lazy的优先级更高,而且在class标签上配置的lazy属性不会影响到关联对象.(本例用的版本是Hibernate3)

本例假设有一个主表为MASTTB,有一个子表为DETAILTB.  
  
主表端的fetch可以取 'join','select'和'subselect'(select为默认值):

join:外连接一次查询.

select:1+n 条select语句,第一条查主表,第n条查第n条主表记录对应的子表记录.

subselect: 以 id in(...)的方式做第二条查询,(如果查询主表的是返回单条记录,subselect和select没有区别,如果查询主表的是返回多条记录的话,对子表查询会以id in 的方式).具体见例4.

lazy可以取'true','extra'以及 'false'(true为默认值):

true:默认取值，它的意思是只有在调用这个集合获取里面的元素对象时,才发出查询语句,加载其集合元素的数据.  
false:取消延迟加载特性，即在加载对象的同时,就发出第二条查询语句加载其关联集合的数据.  
extra:一种比较聪明的延迟加载策略,即调用集合的size/contains等方法的时候,hibernate并不会去加载整个集合的数据,而是发出一条"聪明"的SQL语句,以便获得需要的值,只有在真正需要用到这些集合元素对象数据的时候,才去发出查询语句加载所有对象的数据.  
比如看集合的size:

会发出下面的SQL语句

select  
        count(DTID)  
    from  
        DETAILTB  
    where  
        MTID =?

1,对主表进行findById查询的测试,当fetch设为join的时候, 不管lazy是true还是false,都是一次以主表左外连接子表的方式把关联的数据全部查出来.SQL如下:  
  
    select  
        masttb0\_.MID as MID1\_1\_,  
        masttb0\_.MASTINFO as MASTINFO1\_1\_,  
        detailtbs1\_.MTID as MTID3\_,  
        detailtbs1\_.DTID as DTID3\_,  
        detailtbs1\_.DTID as DTID2\_0\_,  
        detailtbs1\_.MTID as MTID2\_0\_,  
        detailtbs1\_.DETAILINFO as DETAILINFO2\_0\_  
    from  
        MASTTB masttb0\_  
    left outer join  
        DETAILTB detailtbs1\_  
            on masttb0\_.MID=detailtbs1\_.MTID  
    where  
        masttb0\_.MID=?  
  
2,对主表进行findById查询的测试,当fetch设为select的时候,lazy 是true的时候,hibernate先用一条SQL将主表的数据查出来,然后在取子表数据的时候(在访问set的iterator的时候),再以子表的外键作为条件,用SQL语句取子表的数据.  
JAVA代码如下:  
            tx = sessionFactory.getCurrentSession().beginTransaction();  
            MasttbHome masttbHome = new MasttbHome();  
            
            Masttb masttb  = masttbHome.findById(new BigDecimal(1));  
            System.out.println("before getting detai set");  
            
            Set set = masttb.getDetailtbs();  
            
            System.out.println("after getting detai set");  
            Iterator itr = set.iterator();  
            System.out.println("after getting detai set iterator");  
            while(itr.hasNext())\{  
                Detailtb detailtb = (Detailtb)itr.next();  
                System.out.println("after getting detai info " + detailtb.getDtid());  
            \}  
  
            tx.commit();  
运行结果如下:  
Hibernate:  
    select  
        masttb0\_.MID as MID1\_0\_,  
        masttb0\_.MASTINFO as MASTINFO1\_0\_  
    from  
        MASTTB masttb0\_  
    where  
        masttb0\_.MID=?  
before getting detai set  
after getting detai set  
Hibernate:  
    select  
        detailtbs0\_.MTID as MTID1\_,  
        detailtbs0\_.DTID as DTID1\_,  
        detailtbs0\_.DTID as DTID2\_0\_,  
        detailtbs0\_.MTID as MTID2\_0\_,  
        detailtbs0\_.DETAILINFO as DETAILINFO2\_0\_  
    from  
        DETAILTB detailtbs0\_  
    where  
        detailtbs0\_.MTID=?  
after getting detai set iterator  
after getting detai info 2  
after getting detai info 1  
  
3,对主表进行findById查询的测试,当fetch设为select的时候,lazy是false的时候,hibernate先用一条SQL将主表的数据查出来,然后马上再以子表的外键作为条件,用SQL语句取子表的数据.  
上面例2的代码会打印:  
Hibernate:  
    select  
        masttb0\_.MID as MID1\_0\_,  
        masttb0\_.MASTINFO as MASTINFO1\_0\_  
    from  
        MASTTB masttb0\_  
    where  
        masttb0\_.MID=?  
Hibernate:  
    select  
        detailtbs0\_.MTID as MTID1\_,  
        detailtbs0\_.DTID as DTID1\_,  
        detailtbs0\_.DTID as DTID2\_0\_,  
        detailtbs0\_.MTID as MTID2\_0\_,  
        detailtbs0\_.DETAILINFO as DETAILINFO2\_0\_  
    from  
        DETAILTB detailtbs0\_  
    where  
        detailtbs0\_.MTID=?  
before getting detai set  
after getting detai set  
after getting detai set iterator  
after getting detai info 2  
after getting detai info 1  
  
  
\*如果将lazy设为true,fetch设为 select,在session关闭后在去访问set里的值,会出异常.  
 org.hibernate.LazyInitializationException: failed to lazily initialize a collection of role: com.test.hb.Masttb.detailtbs, no session or session was closed

4,对主表进行多条记录查询的测试,当fetch设为subselect的时候,lazy是true的时候,hibernate先用一条SQL将主表的数据查出来,然后用id in 方式的SQL语句取子表的数据.

JAVA代码:

tx = sessionFactory.getCurrentSession().beginTransaction();  
             
            List mstlist = sessionFactory.getCurrentSession().createQuery("from com.test.hb.Masttb where id in (1,2)").list();

//下面的hql和上面的hql有同样的效果

//List mstlist = sessionFactory.getCurrentSession().createQuery("from com.test.hb.Masttb where id <3").list();  
            for (Iterator iter = mstlist.iterator(); iter.hasNext();) \{  
                Masttb masttb = (Masttb) iter.next();  
                System.out.println("masttb.getMastinfo=" + masttb.getMastinfo());  
                Set set = masttb.getDetailtbs();  
                System.out.println(set.size());  
                if (set != null && !set.isEmpty()) \{  
                    for (Iterator itr = set.iterator(); itr.hasNext();) \{  
                        Detailtb detailtb = (Detailtb) itr.next();  
                        System.out.println("detailtb.name=" + detailtb.getDetailinfo());  
                    \}  
                \}  
            \}  
  
            tx.commit();

运行结果:

Hibernate:  
    select  
        masttb0\_.MID as MID1\_,  
        masttb0\_.MASTINFO as MASTINFO1\_  
    from  
        MASTTB masttb0\_  
    where  
        masttb0\_.MID in (  
            1 , 2  
        )  
masttb.getMastinfo=mastinfo  
Hibernate:  
    select  
        detailtbs0\_.MTID as MTID1\_,  
        detailtbs0\_.DTID as DTID1\_,  
        detailtbs0\_.DTID as DTID2\_0\_,  
        detailtbs0\_.MTID as MTID2\_0\_,  
        detailtbs0\_.DETAILINFO as DETAILINFO2\_0\_  
    from  
        DETAILTB detailtbs0\_  
    where  
        detailtbs0\_.MTID in (  
            select  
                masttb0\_.MID  
            from  
                MASTTB masttb0\_  
            where  
                masttb0\_.MID in (  
                    1 , 2  
                )  
        )  
number in detail table: 2  
detailtb.name=aaaa  
detailtb.name=detailinfo2  
masttb.getMastinfo=aaa  
number in detail table: 1  
detailtb.name=adfasdfa

如果fetch=select,lazy=true的话,运行结果为 1 + 2条SQL语句:

Hibernate:  
    select  
        masttb0\_.MID as MID1\_,  
        masttb0\_.MASTINFO as MASTINFO1\_  
    from  
        MASTTB masttb0\_  
    where  
        masttb0\_.MID in (  
            1 , 2  
        )  
masttb.getMastinfo=mastinfo  
Hibernate:  
    select  
        detailtbs0\_.MTID as MTID1\_,  
        detailtbs0\_.DTID as DTID1\_,  
        detailtbs0\_.DTID as DTID2\_0\_,  
        detailtbs0\_.MTID as MTID2\_0\_,  
        detailtbs0\_.DETAILINFO as DETAILINFO2\_0\_  
    from  
        DETAILTB detailtbs0\_  
    where  
        detailtbs0\_.MTID=?  
number in detail table: 2  
detailtb.name=aaaa  
detailtb.name=detailinfo2  
masttb.getMastinfo=aaa  
Hibernate:  
    select  
        detailtbs0\_.MTID as MTID1\_,  
        detailtbs0\_.DTID as DTID1\_,  
        detailtbs0\_.DTID as DTID2\_0\_,  
        detailtbs0\_.MTID as MTID2\_0\_,  
        detailtbs0\_.DETAILINFO as DETAILINFO2\_0\_  
    from  
        DETAILTB detailtbs0\_  
    where  
        detailtbs0\_.MTID=?  
number in detail table: 1  
detailtb.name=adfasdfa

子表端的fetch可以取 'join'和'select'(select为默认值),

join:外连接一次查询.

select:两条select语句.

lazy可以取'proxy','no-proxy'以及'false'(proxy为默认值).

false:取消延迟加载特性，即在加载对象的同时，就发出第二条查询语句加载其关联的主表的数据.

proxy的意思和主表端lazy取true的作用类似,当要访问主表对象的时候,hibernate返回一个proxy对象,这时候还没有去访问数据库取值.  
no-proxy 和proxy效果一样,不过proxy对象不是动态,是在编译的过程中就创建的,需要进行特定的编译(requires build-time bytecode instrumentation).

5,对子表进行findById查询的测试,当fetch设为join的时候,不管lazy是 false还是proxy,都是一次以子表左外连接主表的方式把关联的数据全部查出来.SQL如下:  
    select  
        detailtb0\_.DTID as DTID2\_1\_,  
        detailtb0\_.MTID as MTID2\_1\_,  
        detailtb0\_.DETAILINFO as DETAILINFO2\_1\_,  
        masttb1\_.MID as MID1\_0\_,  
        masttb1\_.MASTINFO as MASTINFO1\_0\_  
    from  
        DETAILTB detailtb0\_  
    left outer join  
        MASTTB masttb1\_  
            on detailtb0\_.MTID=masttb1\_.MID  
    where  
        detailtb0\_.DTID=?  
  
6,对子表进行findById查询的测试,当fetch设为 select的时候,lazy是false,hibernate先用一条SQL将子表的数据查出来,然后马上用子表的外键作为主表的主键的值,将主表的数据的查询出来.  
Hibernate:  
    select  
        detailtb0\_.DTID as DTID2\_0\_,  
        detailtb0\_.MTID as MTID2\_0\_,  
        detailtb0\_.DETAILINFO as DETAILINFO2\_0\_  
    from  
        DETAILTB detailtb0\_  
    where  
        detailtb0\_.DTID=?  
Hibernate:  
    select  
        masttb0\_.MID as MID1\_0\_,  
        masttb0\_.MASTINFO as MASTINFO1\_0\_  
    from  
        MASTTB masttb0\_  
    where  
        masttb0\_.MID=?  
before accessing mast table data  
  
7,对子表进行findById查询的测试,当 fetch设为select的时候,lazy是proxy,hibernate先用一条SQL将子表的数据查出来,然后在需要访问主表数据的时候,再以子表的外键作为主表的主键的值,用SQL语句取主表表的数据.(而且如果你要访问的值是主键值,因为主键值正好是子表的外键值,proxy对象的主键属性已经有值了,hibernate不会发SQL语句查数据库)  
Hibernate:  
    select  
        detailtb0\_.DTID as DTID2\_0\_,  
        detailtb0\_.MTID as MTID2\_0\_,  
        detailtb0\_.DETAILINFO as DETAILINFO2\_0\_  
    from  
        DETAILTB detailtb0\_  
    where  
        detailtb0\_.DTID=?  
before accessing mast table data (没有访问数据之前是不会发SQL语句的)  
Hibernate:  
    select  
        masttb0\_.MID as MID1\_0\_,  
        masttb0\_.MASTINFO as MASTINFO1\_0\_  
    from  
        MASTTB masttb0\_  
    where  
        masttb0\_.MID=?  
  
  
\*同样,如果将lazy设为proxy,fetch设为select,在session关闭后在去访问主表里的值,会出异常(仅仅访问主键值不会有异常).  
 org.hibernate.LazyInitializationException: could not initialize proxy - no Session

需要注意的一个问题:在子表和主表两端都设置为lazy="false"的时候,先查询子表的数据,这是会发出SQL语句查询数据库,根据select的设置,SQL会有所不同.查询主表的数据之后,又会发出一条SQL语句(条件为子表的外键=主表的主键)查询子表(这一步是多余的).

如下代码:

DetailtbHome detailtbHome = new DetailtbHome();  
            Detailtb detailtb = detailtbHome.findById(new BigDecimal(1));

SQL:

Hibernate:  
    select  
        detailtb0\_.DTID as DTID2\_0\_,  
        detailtb0\_.MTID as MTID2\_0\_,  
        detailtb0\_.DETAILINFO as DETAILINFO2\_0\_  
    from  
        DETAILTB detailtb0\_  
    where  
        detailtb0\_.DTID=?  
Hibernate:  
    select  
        masttb0\_.MID as MID1\_0\_,  
        masttb0\_.MASTINFO as MASTINFO1\_0\_  
    from  
        MASTTB masttb0\_  
    where  
        masttb0\_.MID=?  
Hibernate: //由于主表的lazy为false,会发出下面的SQL查询子表  
    select  
        detailtbs0\_.MTID as MTID1\_,  
        detailtbs0\_.DTID as DTID1\_,  
        detailtbs0\_.DTID as DTID2\_0\_,  
        detailtbs0\_.MTID as MTID2\_0\_,  
        detailtbs0\_.DETAILINFO as DETAILINFO2\_0\_  
    from  
        DETAILTB detailtbs0\_  
    where  
        detailtbs0\_.MTID=?  
after findById detailinfo1

通过上面的例子可以发现,最好的做法是:使用hibernate的lazy和fetch的默认设置,这样hibernate的get和load的时候就不会将关联的记录也取出来.而如果需要将关联的记录取出来的时候,用Criteria进行查询,利用Criteria.setFetchMode在代码中进行控制关联记录的查询.或者通过在传入Query的HQL或者SQL 来控制.