Hibernate的一些关联关键字的配置略谈

第一.inverse

inverse常用于一对多双向关联关系中。
以Student（学生）和Class（班级）为例，它们之间的关系为一对多的关系，即一个学生只能属于一个班级，一个班级可以包含多个学

生。
学生类定义代码：
Class Student{
  private int id;
  private String name;
  private Class class;
  //省略getter()和setter()方法
}
班级类定义代码：
Class Class{
  private int id;
  private String name;
  private Set students = new HashSet();
  //省略getter()和setter()方法
}
Student类的映射文件：
<class name="Student" table="STUDENT">
   <id name="id" type="int" column="ID">
      <generator class="native" />  
   </id>
   <property name="name" type="string" column="NAME" />
   <many-to-one name="class" column="CLASS_ID" class="Class" cascade="save-update" /> 
</class>
Class类的映射文件：
<class name="Class" table="CLASS">
   <id name="id" type="int" column="ID">
     <generator class="native" />  
   </id>
   <property name="name" type="string" column="NAME" />
   <set name="students" table="STUDENT" cascade="save-update" inverse="false">
     <key column="CLASS_ID" />
     <one-to-many class="Student" />
   </set>
</class>
希望你能对这两个映射文件所表达的数据库模式有正确的认识。即STUDENT表中存在一个名为CLASS_ID的字段，它和CLASS表中的ID字段是主外键关系。那个inverse属性就是用来规定是由谁（Student或Class）来维护这个主外键关系的。
inverse的默认值为false。
在处理逻辑代码中，如下：
Class c1 = new Class();
c1.setName("一班");
Student s1 = new Student();
Student s2 = new Student();
s1.setName("Jason");
s2.setName("Tom");
c1.getStudents().add(s1);
c2.getStudents().add(s2);
s1.setClass(c1);
s2.setClass(c1);   //注释1
session.save(c1);
上面的代码会使Hibernate执行五条SQL语句，其中前三条是insert插入语句，后两条是update更新语句。插入就不用说了，那么为什么还要有更新语句呢？这是因为Class类映射文件的<set>元素中指定了inverse="false"，这就告之Hibernate：STUDENT表与CLASS表的主外键关系是由Class类来维护的。当执行save后，执行了三条insert语句，这三条语句中的后两条是插入到STUDENT表的，它们的CLASS_ID字段是通过s1.getClass().getID()取出的，假如我将上面“注释1”处修改为s2.setClass(c2);（c2是另一个Class对象，可能是持久化对象），这样，主外键关系不就乱了吗。为了保证主外键关系，Hibernate在这种情况下会再执行两条update语句来更改STUDENT表中两个新插入记录的CLASS_ID字段，当然，这时CLASS_ID字段的取值是从c1对象中直接取得，而不再是s1.getClass().getID()方式了。
如果我们将Class类映射文件的<set>元素中的inverse属性修改为true，这就是告诉Hibernate：Class类不维护主外键关系了，这个任务就交给了Student类。于是，我们再执行上面的代码，Hibernate就会只执行三条insert语句，而不会执行任何update语句。因为Hibernate会通过Student类的s1.getClass().getID()和s2.getClass().getID()来确定CLASS_ID字段的值。
故，为了节省数据库资源，省却不必要的update语句，我们一般建议在一对多双向关联关系中，将一方的inverse属性设置为true，即将主外键的关系交由多方来维护。
打个比方：在一个公司中，是老板认识所有的员工容易，还是所有员工认识老板容易？

第二 lazy

lazy，延迟加载

Lazy的有效期：只有在session打开的时候才有效；session关闭后lazy就没效了。

lazy策略可以用在：

* <class>标签上：可以取值true/false

* <property>标签上，可以取值true/false，这个特性需要类增强

* <set>/<list>等集合上，可以取值为true/false/extra

* <one-to-one>/<many-to-one>等标签上，可以取值false/proxy/no-proxy

6.1 get和load的区别：

* get不支持延迟加载，而load支持。

* 当查询特定的数据库中不存在的数据时，get会返回null，而load则抛出异常。

6.2 类(Class)的延迟加载：

* 设置<class>标签中的lazy="true",或是保持默认（即不配置lazy属性)

* 如果lazy的属性值为true，那么在使用load方法加载数据时，只有确实用到数据的时候才会发出sql语句；这样有可能减少系统的开销。

* //不会发出查询sql

       System.out.println("group id=" + group.getId());

这里有一个问题，为什么加载主键的时候不需要发出sql语句。

6.3 集合(collection)的延迟加载：可以取值true，false，extra

* 保持集合上的lazy的默认值，此时的效果和lazy="extra"是基本一样的。

   * 设置集合上的lazy=extra,此时的效果和lazy属性的默认值是基本一样的。但是推荐使用这个属性值，因为在统计时这种情况显得比较智能。当然延迟是有效果的。

* 设置集合上的lazy=false

true:默认取值，它的意思是只有在调用这个集合获取里面的元素对象时，才发出查询语句，加载其集合元素的数据

false:取消懒加载特性，即在加载对象的同时，就发出第二条查询语句加载其关联集合的数据

extra:一种比较聪明的懒加载策略，即调用集合的size/contains等方法的时候，hibernate

并不会去加载整个集合的数据，而是发出一条聪明的SQL语句，以便获得需要的值，只有在真正需要用到这些集合元素对象数据的时候，才去发出查询语句加载所有对象的数据

6.4 Hibernate单端关联懒加载策略：即在<one-to-one>/<many-to-one>标签上可以配置

懒加载策略。可以取值为：false/proxy/no-proxy

false:取消懒加载策略，即在加载对象的同时，发出查询语句，加载其关联对象

proxy:这是hibernate对单端关联的默认懒加载策略，即只有在调用到其关联对象的方法的时候才真正发出查询语句查询其对象数据，其关联对象是代理类

no-proxy:这种懒加载特性需要对类进行增强，使用no-proxy，其关联对象不是代理类

注意：在class标签上配置的lazy属性不会影响到关联对象!!!

如果配置不恰当，可能引起系统在查询时关联很多无用的数据，导致访问很慢。

第三 cascade

Hibernate 级联关系说明 － 关于cascade和inverse的用法

在hibernate中一对多关联时会经常用到inverse和cascade属性 ,

inverse 有两个值 true ,false  ;如果设置为true 则表示当前对象不负责将级联对象的状态变化同步到数据库 ;设置false则相反,其默认值为false;

cascade 有五个选项 分别是: all ,delete ,none,save-update,delete-orphan ;
         all : 所有情况下均进行关联操作。
         none：所有情况下均不进行关联操作。这是默认值。
         save-update:在执行save/update/saveOrUpdate时进行关联操作。
         delete：在执行delete时进行关联操作。
         delete-orphan: 当save/update/saveOrUpdate时，相当于save-update ；当删除操作时，相当于delete ；

all的意思是save-update + delete
all-delete-orphan 的意思是当对象图中产生孤儿节点时,在数据库中删除该节点
all比较好理解,举个例子说一下all-delete-orphan:
 Category与Item是一对多的关系,也就是说Category类中有个Set类型的变量items.
 举个例子,现items中存两个Item, item1,item2,如果定义关系为all-delete-orphan
 当items中删除掉一个item(比如用remove()方法删除item1),那么被删除的Item类实例
 将变成孤儿节点,当执行category.update(),或session.flush()时
hibernate同步缓存和数据库,会把数据库中item1对应的记录删掉

测试Hibernate中的三个属性:lazy,inverse,cascade

【测试环境】
 一对多关系的两张表：boy、girl（一个男孩可以多个女朋友）

 boy表结构
  Field   Type        
  ------  ----------- 
  name    varchar(50)  pk
  age     varchar(50) 

 girl表结构
  Field   Type        
  ------  ----------- 
  name    varchar(50)  pk
  bf      varchar(50)  fk 

【保存时：Inverse与cascade】

 创建三个girl对象和一个boy对象，让这是三个girl都是boy的女朋友

  ---------创建对象的代码片段-----------
   Boy boy = new Boy("tom","23", null);

  Set girls = new HashSet();
   
   Girl g[] = new Girl[]{
                         new Girl("Alice1", boy),
                         new Girl("Alice2", boy),
                         new Girl("Alice3", boy)};
   girls.add(g[0]);
   girls.add(g[1]);
   girls.add(g[2]);
   
   boy.setGirls(girls);
  
  在Boy.hbm.xml中设置，然后对boy对象进行保存。

 1.Inverse = true，不指定cascade
    cascade的默认值为none, 当对boy进行保存操作时,girl什么都不做. 所以只保存了boy对象, 没有保存girl对象

 2.Inverse = true，cascade=all
    boy与girl对象，包扩外键[K1] 都成功保存。
    (生成3条SELECT语句和[K2] 4条INSERT语句，一下简称SELECT 3, INSERT 4)

 3.Inverse = false，不指定cascade
    报错。因为boy为主控方，负责维护关系，所以在插入boy对象后，会尝试修改并不存在的girl对象。

 4.Inverse = false，cascade=all
    boy与girl对象，包扩外键都成功保存。
    (SELECT 4,[K3]  INSERT 4, UPDATE 3)

   分析：除了4条INSERT语句之外，其他的6条语句是我们为了图方便付出的代价：3条SELECT语句用来判断girl对象是否在数据表中已经存在，3条UPDATE语句是为了维护外键关系

 高效率的做法：在Boy.hbm.xml中设置Inverse=true，在Girl.hbm.xml中设置Inverse=false[K4] , cascade=all，然后保存三个girl对象
  (SELECT 1, INSERT 4)

   高效率的代价就是保存的时候比较麻烦

【删除时：Inverse与cascade】

 希望通过删除boy，也将3个girl对象删除。程序中先查出boy对象，然后进行删除
   -----------------------------------------
   Boy boy = (Boy) s.get(Boy.class, "tom");
   s.delete(boy);
   -----------------------------------------

  同样在Boy.hbm.xml中进行设置

 1.Inverse = true
    可以猜到结果是出错。原因：外键约束错误

 2.Inverse = false
    boy删除，girl表中外键变为null，没有删除记录 ;  
 (UPDATE 1, DELETE 1)

 3.Inverse = false, cascade = all
       全部删除  ;在删除有外键的从表时,先把从表外键置为null,然后删除主表记录,最后根据从表主键删除所有相关从表记录

    (UPDATE 1, DELETE 4)

 4.Inverse = true, cascade = all
    全部删除
    (DELETE 4)

Inverse是hibernate双向关联中的基本概念，当然对于多数实体，我们并不需要双向关联，更多的可能会选择单向关联，况且我们大多数人一般采用一对多关系，而一对多双向关联的另一端：多对一的inverse属性是不存在，其实 它默认就是inverse=false.从而防止了在一对多端胡乱设置inverse也不至于出错。但是inverse设置不当确实会带来很大的性能影响，这点是我们必须关注的。

这篇文章已经详细分析了inverse设置不当带来的影响：

http://www.hibernate.org/155.html

看了这篇文章，还是很有必要再写下一些总结的：

1）inverse中提及的side其实是指一个类或者表的概念，双向关联其实是指双方都可以取得对方的应用。

2） 维护关系这个名词还是稍显模糊或者晦涩。我们一般说A类或者A表（这里的表的是指多对多的连接表）有责任维护关系，其实这里的意思是说，我在应用在更新，创建，删除（读就不用说了，双向引用正是为了方便读而出现）A类或者A表时，此时创建的SQL语句必须有责任保证关系的正确修改。

3）inverse=false的side（side其实是指inverse＝false所位于的class元素）端有责任维护关系，而inverse＝true端无须维护这些关系。

4） 我们说inverse设立不当会导致性能低下，其实是说inverse设立不当，会产生多余重复的SQL语句甚至致使JDBC exception的throw。这是我们在建立实体类关系时必须需要关注的地方。一般来说，inverse＝true是推荐使用，双向关联中双方都设置 inverse＝false的话，必会导致双方都重复更新同一个关系。但是如果双方都设立inverse＝true的话，双方都不维护关系的更新，这也是不行的，好在一对多中的一端:many-to-one默认是inverse＝false，避免了这种错误的产生。但是多对多就没有这个默认设置了，所以很多人经常在多对多的两端都使用inverse＝true，结果导致连接表的数据根本没有记录，就是因为他们双分都没有责任维护关系。所以说，双向关联中最好的设置是一端为inverse＝true，一端为inverse＝false。一般inverse＝false会放在多的一端，那么有人提问了， many－to－many两边都是多的，inverse到底放在哪儿？其实hibernate建立多对多关系也是将他们分离成两个一对多关系，中间连接一个连接表。所以通用存在一对多的关系，也可以这样说：一对多是多对多的基本组成部分。

看下面的多对多的定义大家更会清楚”多对多“与“一对多”的关系：其中我们注意<many-to-many />标签的特点就知道，它是定义了一个多对多关系，而不是<one-to-many/>。

<?xml version="1.0"?>
 <!DOCTYPE hibernate-mapping PUBLIC
  "-//Hibernate/Hibernate Mapping DTD 2.0//EN"
  "http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd">
 <hibernate-mapping  package="org.hibernate.auction">
  <class name="TestA" table="TestA"
  dynamic-update="true" dynamic-insert="true" >

  <id name="id" column="id" type="int" unsaved-value="any" >
    <generator class="assigned">
    </generator>
   </id>

  <property name="name" type="java.lang.String"
    update="true" insert="true" column="name" />

  <set name="testBs" table="TestA_TestB" inverse="false" cascade="all">
    <key column="testA"/>
    <many-to-many column="testB" class="TestB" />
   </set>

  </class>
  <class name="TestB" table="TestB"
  dynamic-update="true" dynamic-insert="true" >

  <id name="id" column="id" type="int" unsaved-value="any" >
    <generator class="assigned">
    </generator>
   </id>

  <property name="name" type="java.lang.String" update="true"
   insert="true" column="name" />

  <set name="testAs" table="TestA_TestB" inverse="true" cascade="all">
    <key column="testB"/>
    <many-to-many column="testA" class="TestA" />
   </set>

  </class>
 </hibernate-mapping>

在对多对中，因为一端维护关系另一端不维护关系的原因，我们必须注意避免在应用中用不维护关系的类建立关系，因为这样建立的关系是不会在数据库中存储的。基于上面的映射文件代码给出一个例子：

package org.hibernate.auction;
 import java.util.*;

/**
  * @author Administrator
  *
  * To change the template for this generated type comment go to
  * Window>Preferences>Java>Code Generation>Code and Comments
  */
 public class TestA {
  int id;
  String name;
  Set testBs=new HashSet();
  public TestA(){
   
  }
  public TestA(int id){
   setId(id);
  }
  public int getId(){
   return id;
  }
  public void setId(int id){
   this.id=id;
  }
  public String getName(){
   return name;
  }
  public void setName(String name){
   this.name=name;
  }
  public Set getTestBs(){
   return testBs;
  }
  public void setTestBs(Set s){
   testBs=s;
  }
  public void addTestB(TestB tb){
   testBs.add(tb);
  }

 public static void main(String[] args) {
  }
 }

public class TestB {

 
  int id;
  String name;
  Set testAs=new HashSet();
  public TestB(){
   
  }
  public TestB(int id){
   setId(id);
  }
  public int getId(){
   return id;
  }
  public void setId(int id){
   this.id=id;
  }
  public String getName(){
   return name;
  }
  public void setName(String name){
   this.name=name;
  }
  public Set getTestAs(){
   return testAs;
  }
  public void setTestAs(Set s){
   testAs=s;
  }
  public void addTestA(TestA ta){
   testAs.add(ta);
  }
  public static void main(String[] args) {
  }
 }

测试代码：

public void doTest() throws Exception{
   TestA a1=new TestA(1);
   TestA a2=new TestA(2);
   TestA a3=new TestA(3);
   TestB b1=new TestB(1);
   TestB b2=new TestB(2);
   TestB b3=new TestB(3);
   a1.addTestB(b1);
   a1.addTestB(b2);
   a1.addTestB(b3);
   b2.addTestA(a1);
   b2.addTestA(a2);
   
   Session s = factory.openSession();
   
   s = factory.openSession();
   
   
   Session session = factory.openSession();
   session.save(a1);
   session.flush();
   session.close();

 }

测试后连接表的数据为：

testa              testb

1                  1

1                  2

1                  3

根据inverse规则，对这些代码：b2.addTestA(a1);  b2.addTestA(a2); 建立的关系，数据库并没有存储下来，因为TestB没有责任维护这些关系，所以产生的sql语句自然不会有针对Testa_testB表的操作了。假设应用中真的需要这些方法，那么我们可以修改TestB的方法，让他们注意在维护端类中执行相应的操作以使得关系能够在数据库中保存下来，更改TestB如 下：

/*
  * Created on 2004-7-25
  *
  * To change the template for this generated file go to
  * Window>Preferences>Java>Code Generation>Code and Comments
  */
 package org.hibernate.auction;
 import java.util.*;

/**
  * @author Administrator
  *
  * To change the template for this generated type comment go to
  * Window>Preferences>Java>Code Generation>Code and Comments
  */
 public class TestB {

 
  int id;
  String name;
  Set testAs=new HashSet();
  public TestB(){
   
  }
  public TestB(int id){
   setId(id);
  }
  public int getId(){
   return id;
  }
  public void setId(int id){
   this.id=id;
  }
  public String getName(){
   return name;
  }
  public void setName(String name){
   this.name=name;
  }
  public Set getTestAs(){
   return testAs;
  }
  public void setTestAs(Set s){
   testAs=s;
  }
  public void addTestA(TestA ta){
   testAs.add(ta);
   ta.addTestB(this);
  }
  public static void main(String[] args) {
  }
 }
 那么测试执行后连接表的数据为：

testa          testb

1               2

1               3

1                1

2                 2

测试通过。


附 hibernate cascade备忘 ：
当关联双方存在父子关系，就可以在 set 处设定 cascade 为 all-delete-orphan

所谓父子关系，即指由父方控制子方的持久化圣明周期，子方对象必须和一个父方对象关联。如果删除父方对象，应该级联删除所有关联的子方对象；如果一个子方对象不再和一个父方对象关联，应该把这个子方对象删除。

all-delete-orphan 的能力：

1. 当保存或更新父方对象时，级联保存或更新所有关联的子方对象，相当于 cascade 为 save-update

2. 当删除父方对象时，级联删除所有关联的子方对象，相当于 cascade 为 delete

3. 删除不再和父方对象关联的所有子方对象

解除父子关系的 java 语句例如：

customer.getOrders().remove(order);
order.setCustomer(null);

tx.commit();

如果 cascade 属性取默认值 null，当解除父子关系时，会执行如下 sql：

update ORDER set CUSTOMER_ID=null where ID=2

inverse 设定的原则：

1. 在映射一对多双向关联关系时，应该设定 many 方的 inverse 为 true，以提高性能

2. 在建立两个对象的双向关联时，应同时修改关联两端的对象的相应属性：

1）customer.getOrders().add(order);
2）order.setCustomer(customer);

如果不执行 1）而仅执行 2），由于 set 元素的 inverse 为 true，因此 hibernate 不会按照 CUSTOMER 对象的状态变化来同步数据库。

inverse 解决性能问题的例子：

1. 建立 Order 到 Customer 的多对一关联关系

order.setCustomer(customer);

相应执行的 SQL 为：

update ORDERS set ORDER_NUMBER=''Jack_Order001'', CUSTOMER_ID=2 where ID=2;

2. 建立 Customer 到 Order 的一对多关系

customer.getOrders().add(order);

相应 SQL 为：

update ORDERS set CUSTOMER_ID=2 where ID=2;

显然 1 和 2 的 SQL 功能重复了，反复执行这样的 SQL 语句会引起性能下降，因此：

inverse 设定为 true 时，声明 Customer 端的关联只是 Order 端关联的镜像。当两者状态发生变化时，Hibernate 仅按照 Order 对象状态变化来同步数据库。即仅会执行以下 SQL：

update ORDERS set ORDER_NUMBER=''Jack_Order001'', CUSTOME_ID=2 where ID=2;

Customer.hbm.xml 片段如下：
<set
name="orders"
cascade="all-delete-orphan"
inverse="true"
>
<key column="CUSTOMER_ID" />
<one-to-many class="mypack.Order" />
</set>

  
  

 
 

  
  

   
   
经过测试，发现外键没有成保存，值为null
  
  
 
 
 
 

  
  

   
   
我验证时没有select语句
  
  
 
 
 
 

  
  

   
   
同样这里也没有select语句
  
  
 
 
 
 

  
  

   
   
Girl这边找不到inverse选项，无法进行试验
   
   
 
   
   
 
  
  
 
 

第四，dynamic-insert="true" dynamic-update="true" 

在Hibernate的映射文件的class tag使用dynamic-insert，dynamic-update，可以优化生成的SQL语句，提高SQL执行效率，最终可以提高系统性能。

public class User {    

      

    /** Creates a new instance of User */  

    public User() {   

    }   

    private long id;   

    private int age;   

  

    private String firstname;   

    private String lastname;   

    private Set emailAddresses;   

//省略getter 和setter方法   

}   

 

<hibernate-mapping>  

    <class name="model.User" table="Users" >  

        <id name="id" column="ID">  

            <generator class="native"/>  

        </id>  

        <property name="age"/>  

        <property name="firstname"/>  

        <property name="lastname"/>  

          

      <set name="emailAddresses" table="PERSON_EMAIL_ADDR">  

          <key column="PERSON_ID"/>   

            <element type="string" column="EMAIL_ADDR"/>  

        </set>  

  </class>  

</hibernate-mapping>  

 

 

public class UserTest extends TestCase {   

       

    public UserTest(String testName) {   

        super(testName);   

    }   

      

    private Session session;   

    private SessionFactory sessionFactory;   

       

   protected void setUp() throws Exception {   

      sessionFactory=HibernateUtil.getSessionFactory();   

      session=sessionFactory.openSession();   

       session.getTransaction().begin();   

    }   

       

    protected void tearDown() throws Exception {   

       session.getTransaction().commit();   

        session.close();   

           

   }   

      

    /**  

     * Test of getAge method, of class model.User.  

     */  

    public void testSaveUser() {   

        System.out.println("================testSaveUser=================");   

           

       User user = new User();   

        user.setAge(29);   

        session.save(user);   

        assertNotNull("id is assigned !",user.getId());   

    }   

    public void testUpdateUser() {   

        System.out.println("================testUpdateUser=================");   

           

        User user = new User();   

        user.setAge(29);   

        session.save(user);   

        assertNotNull("id is assigned !",user.getId());   

           

        User _user=(User) session.get(User.class, user.getId());   

        _user.setFirstname("Array");   

        session.update(_user);   

           

    }   

       

   }   

运行测试后，此时会生成完整的SQL语句（注意将hibernate属性show_sql设置成true）。

================testSaveUser=================   

Hibernate: insert into Users (age, firstname, lastname) values (?, ?, ?)   

================testUpdateUser=================   

Hibernate: insert into Users (age, firstname, lastname) values (?, ?, ?)   

Hibernate: update Users set age=?, firstname=?, lastname=? where ID=?  

 

如果我们在<class ...>中加上 dynamic-insert="true" dynamic-update="true"，变成如下。

<class name="model.User" table="Users" dynamic-insert="true" dynamic-update="true">  

 

================testSaveUser=================   

Hibernate: insert into Users (age) values (?)   

================testUpdateUser=================   

Hibernate: insert into Users (age) values (?)   

Hibernate: update Users set firstname=? where ID=?  

 

 

 

第五：Hibernate的fetch="join"和fetch="select" 的一点分析 

fetch参数指定了关联对象抓取的方式是select查询还是join查询，select方式时先查询返回要查询的主体对象（列表），再根据关联外键id，每一个对象发一个select查询，获取关联的对象，形成n+1次查询；
而join方式，主体对象和关联对象用一句外键关联的sql同时查询出来，不会形成多次查询。
如果你的关联对象是延迟加载的，它当然不会去查询关联对象。
另外，在hql查询中配置文件中设置的join方式是不起作用的（而在所有其他查询方式如get、criteria或再关联获取等等都是有效的），会使用select方式，除非你在hql中指定join fetch某个关联对象。

 

fetch策略用于定义 get/load一个对象时，如何获取非lazy的对象/集合。 这些参数在Query中无效。

fetch策略用于定义 get/load一个对象时，如何获取非lazy的对象/集合。 这些参数在Query中无效。

 

查询抓取（默认的）在N+1查询的情况下是不好的，因此我们可能会要求在映射文档中定义使用连接抓取：

 

<set name="permissions"
fetch="join">
<key column="userId"/>
<one-to-many class="Permission"/>
</set
<many-to-one name="mother" class="Cat" fetch="join"/>
在映射文档中定义的抓取策略将会有产生以下影响：

通过get()或load()方法取得数据。

只有在关联之间进行导航时，才会隐式的取得数据(延迟抓取)。

条件查询

在映射文档中显式的声明 连接抓取做为抓取策略并不会影响到随后的HQL查询。

通常情况下，我们并不使用映射文档进行抓取策略的定制。更多的是，保持其默认值，然后在特定的事务中， 使用HQL的左连接抓取（left join fetch） 对其进行重载。这将通知 Hibernate在第一次查询中使用外部关联（outer join），直接得到其关联数据。 在条件查询 API中，应该调用 setFetchMode(FetchMode.JOIN)语句。

其实这并不能说明hql能够按照配置文件设置的join进行抓取，这时 第二级:topic-->forum 的抓取其实已经和hql没有关系了，因为前面已经产生了另一个select方式的抓取语句。
而是对象的关联获取，假如查询message时topic是设置为延迟加载的，那么在后面获取message.topic时，如topic.forum不延迟加载，那么topic-->forum会实现配置的join方式的抓取，这个显然和hql查询没有关系