Hibernate中outer-join与lazy关键字的使用，解决大家的困惑。
<hibernate-mapping> <class name="com.meagle.bo.Order" table="Orders" dynamic-update="false" dynamic-insert="false" > <id name="id" column="Order_ID" type="int" unsaved-value="0"> <generator class="native"> </generator> </id> <set name="orderLineItems" table="OrderLineItem" lazy="true" inverse="true" cascade="save-update" sort="unsorted"> <key column="Order_ID" ></key> <one-to-many class="com.meagle.bo.OrderLineItem" /> </set> <property name="userName" type="string" update="true" insert="true" access="property" column="UserName" not-null="true" unique="false" />
<property name="total" type="double" update="true" insert="true" access="property" column="Total" not-null="false" unique="false" /> </class>
</hibernate-mapping><hibernate-mapping> <class name="com.meagle.bo.OrderLineItem" table="OrderLineItem" dynamic-update="false" dynamic-insert="false" > <id name="id" column="OrderLineItem_ID" type="int" unsaved-value="0"> <generator class="native"> </generator> </id> <many-to-one name="order" class="com.meagle.bo.Order" cascade="none" outer-join="auto" update="true" insert="true" access="property" column="Order_ID" />
<property name="description" type="string" update="true" insert="true" access="property" column="Description" not-null="false" unique="false" />
<property name="lineItemPrice" type="double" update="true" insert="true" access="property" column="LineItemPrice" not-null="false" unique="false" /> </class>
</hibernate-mapping>
近来一直困惑与outer-join关键字，经过多次测试之后，现总结如下：
1、outer-join关键字(many-to-one的情况)
outer-join关键字有3个值，分别是true,false,auto,默认是auto。true: 表示使用外连接抓取关联的内容，这里的意思是当使用load(OrderLineItem.class,"id")时，Hibernate只生成一条SQL语句将OrderLineItem与他的父亲Order全部初始化。select * from OrderLineItem o left join Order p on o.OrderId=p.OrderId where o.OrderLineItem_Id=?false:表示不使用外连接抓取关联的内容，当load(OrderLineItem.class,"id")时，Hibernate生成两条SQL语句，一条查询OrderLineItem表，另一条查询Order表。这样的好处是可以设置延迟加载，此处要将Order类设置为lazy=true。select * from OrderLineItem o where o.OrderLineItem_Id=?select * from Order p where p.OrderId=?auto:具体是ture还是false看hibernate.cfg.xml中的配置
注意：如果使用HQL查询OrderLineItem，如 from OrderLineItem o where o.id='id'，总是不使用外部抓取，及outer-join失效。
2、outer-join(集合)由于集合可以设置lazy="true"，所以lazy与outer-join不能同时为true，当lazy="true"时，outer-join将一直是false，如果lazy="false"，则outer-join用法与1同3、HQL语句会将POJO配置文件中的关联一并查询，即使在HQL语句中没有明确join。
4、In HQL, the "fetch join" clause can be used for per-query specific outer join fetching. One important thing many people miss there, is that HQL queries will ignore the outer-join attribute you specified in your mapping. This makes it possible to configure the default loading behaviour of session.load() and session.get() and of objects loaded by navigating relationship. So if you specifyand then doMyObject obj = session.createQuery("from MyObject").uniqueResult();
obj.getMySet().iterator().next();
you will still have an additional query and no outer-join. So you must explicily request the outer-join fetching:MyObject obj = session.createQuery(
"from MyObject mo left join fetch mo.mySet").uniqueResult();
obj.getMySet().iterator().next();
Another important thing to know is that you can only fetch one collection reference in a query. That means you can just use one fetch join. You can however fetch "one" references in addition, as this sample from the Hibernate Docs demonstrates:from eg.Cat as cat
inner join fetch cat.mate
left join fetch cat.kittens
We have once considered lifting this limitation, but then decided against it, because using more than one fetch-join would be a bad idea generally: The generated ResultSet becomes huge and is a major performance loss.
So alltogether the "fetch join" clause is an important instrument Hibernate users should learn how to leverage, as it allows tuning the fetch behaviour of a certain use case.
5、join fetch 与 join 的区别
如果HQL使用了连接，但是没有使用fetch关键字，则生成的SQL语句虽然有连接，但是并没有取连接表的数据，还是需要单独的sql取数据，也就是 select a,b,d...中没有连接表的字段
6、如果集合被声明为lazy=true，在HQL中如果显式的使用 join fetch 则延迟加载失效。
Hibernate中outer-join与lazy关键字的使用，解决大家的困惑。
<hibernate-mapping> <class name="com.meagle.bo.Order" table="Orders" dynamic-update="false" dynamic-insert="false" > <id name="id" column="Order_ID" type="int" unsaved-value="0"> <generator class="native"> </generator> </id> <set name="orderLineItems" table="OrderLineItem" lazy="true" inverse="true" cascade="save-update" sort="unsorted"> <key column="Order_ID" ></key> <one-to-many class="com.meagle.bo.OrderLineItem" /> </set> <property name="userName" type="string" update="true" insert="true" access="property" column="UserName" not-null="true" unique="false" />
<property name="total" type="double" update="true" insert="true" access="property" column="Total" not-null="false" unique="false" /> </class>
</hibernate-mapping><hibernate-mapping> <class name="com.meagle.bo.OrderLineItem" table="OrderLineItem" dynamic-update="false" dynamic-insert="false" > <id name="id" column="OrderLineItem_ID" type="int" unsaved-value="0"> <generator class="native"> </generator> </id> <many-to-one name="order" class="com.meagle.bo.Order" cascade="none" outer-join="auto" update="true" insert="true" access="property" column="Order_ID" />
<property name="description" type="string" update="true" insert="true" access="property" column="Description" not-null="false" unique="false" />
<property name="lineItemPrice" type="double" update="true" insert="true" access="property" column="LineItemPrice" not-null="false" unique="false" /> </class>
</hibernate-mapping>
近来一直困惑与outer-join关键字，经过多次测试之后，现总结如下：
1、outer-join关键字(many-to-one的情况)
outer-join关键字有3个值，分别是true,false,auto,默认是auto。true: 表示使用外连接抓取关联的内容，这里的意思是当使用load(OrderLineItem.class,"id")时，Hibernate只生成一条SQL语句将OrderLineItem与他的父亲Order全部初始化。select * from OrderLineItem o left join Order p on o.OrderId=p.OrderId where o.OrderLineItem_Id=?false:表示不使用外连接抓取关联的内容，当load(OrderLineItem.class,"id")时，Hibernate生成两条SQL语句，一条查询OrderLineItem表，另一条查询Order表。这样的好处是可以设置延迟加载，此处要将Order类设置为lazy=true。select * from OrderLineItem o where o.OrderLineItem_Id=?select * from Order p where p.OrderId=?auto:具体是ture还是false看hibernate.cfg.xml中的配置
注意：如果使用HQL查询OrderLineItem，如 from OrderLineItem o where o.id='id'，总是不使用外部抓取，及outer-join失效。
2、outer-join(集合)由于集合可以设置lazy="true"，所以lazy与outer-join不能同时为true，当lazy="true"时，outer-join将一直是false，如果lazy="false"，则outer-join用法与1同3、HQL语句会将POJO配置文件中的关联一并查询，即使在HQL语句中没有明确join。
4、In HQL, the "fetch join" clause can be used for per-query specific outer join fetching. One important thing many people miss there, is that HQL queries will ignore the outer-join attribute you specified in your mapping. This makes it possible to configure the default loading behaviour of session.load() and session.get() and of objects loaded by navigating relationship. So if you specifyand then doMyObject obj = session.createQuery("from MyObject").uniqueResult();
obj.getMySet().iterator().next();
you will still have an additional query and no outer-join. So you must explicily request the outer-join fetching:MyObject obj = session.createQuery(
"from MyObject mo left join fetch mo.mySet").uniqueResult();
obj.getMySet().iterator().next();
Another important thing to know is that you can only fetch one collection reference in a query. That means you can just use one fetch join. You can however fetch "one" references in addition, as this sample from the Hibernate Docs demonstrates:from eg.Cat as cat
inner join fetch cat.mate
left join fetch cat.kittens
We have once considered lifting this limitation, but then decided against it, because using more than one fetch-join would be a bad idea generally: The generated ResultSet becomes huge and is a major performance loss.
So alltogether the "fetch join" clause is an important instrument Hibernate users should learn how to leverage, as it allows tuning the fetch behaviour of a certain use case.
5、join fetch 与 join 的区别
如果HQL使用了连接，但是没有使用fetch关键字，则生成的SQL语句虽然有连接，但是并没有取连接表的数据，还是需要单独的sql取数据，也就是 select a,b,d...中没有连接表的字段
6、如果集合被声明为lazy=true，在HQL中如果显式的使用 join fetch 则延迟加载失效。
.: 
