hibernate FetchType和FetchMode

fetchtype有两个选项：eager和lazy。eager代表立即查询出关联的对象的记录，lazy代表用到的时候才去查询。fetchMode有三个选项：join ,select ,subselect。
以例子说明（teacher和clazz是多对多关联）：
实体类配置如下：

@Entity
@Table(name="teacher")
public class Teacher implements Serializable {
    private static final long serialVersionUID = 1L;

    @Id
    @GeneratedValue(strategy=GenerationType.IDENTITY)
    private Integer id;

    @ManyToMany(mappedBy="teachers",cascade=CascadeType.ALL,fetch=FetchType.EAGER)
    @Fetch(value=FetchMode.SUBSELECT)
    private Set<Clazz> clazzs;
    private Set<Clazz> clazzs;
    ...get,set...
}

首先，用session和主键ID的方式获取记录（此时teacher表只有一条满足条件的记录）：
测试代码是一样的，如下：

Teacher teacher=(Teacher)session.get(Teacher.class, 1);
System.out.println(teacher.getName());
System.out.println("aaa");
Set<Clazz> clazzs=teacher.getClazzs();
Iterator<Clazz> iterator=clazzs.iterator();
while(iterator.hasNext()){
    Clazz clazz=iterator.next();
    System.out.println(clazz.getName());
}

1，fetchmode=join :
fetch=lazy和eager都是一样的：
结果：会发出一条sql，teacher left out join teacher_class left join class。。。也就是说，会把关联的记录都查找出来。然后打印aaa，然后打印属性值。
2，fetchMode=SELECT
（1）fetch=lazy：
结果：会先查询teacher表；然后打印aaa，然后打印teacher表属性值，然后查询中间表teacher_class和class表，然后打印class表属性值；
（2）fetch=eager
结果：先查询teacher表，然后查询中间表teacher_class inner join class表，然后打印aaa，然后打印teacher表和class表属性值；
3，fetchMode=SUBSELECT：
（1）fetch=lazy：
结果：先查询teacher表，然后打印aaa，然后打印teacher表属性值，然后查询中间表teacher_class inner join class表，然后打印class属性值；
（2）fetch=eager：
结果：先查询teacher表，然后查询中间表teacher_class inner join class表，然后打印aaa，然后打印teacher表和class表属性值；

上面是用的session和主键ID的方式，下面使用hql的方式：
测试代码：

String hql="from Teacher t where t.id>10";//该sql返回三个teacher对象
@SuppressWarnings("unchecked")
List<Teacher> teachers=session.createQuery(hql).list();
for(int i=0;i<teachers.size();i++){
System.out.println("aaa");
    Teacher teacher=teachers.get(i);
    System.out.println(teacher.getName());
    Set<Clazz> clazzs=teacher.getClazzs();
    Iterator<Clazz> iterator=clazzs.iterator();
    while(iterator.hasNext()){
        Clazz clazz=iterator.next();
        System.out.println(clazz.getName());
    }
}

实体类和上面一样。
1，fetchMode=JOIN：
（1）fetch=lazy：
结果：先查询teacher表，然后连续发出三条sql查询中间表teacher_class inner join class表；然后打印aaa，然后打印teacher和class属性值；
（2）fetch=eager：
结果：先查询teacher表，然后连续发出三条sql查询中间表teacher_class inner join class表；然后打印aaa，然后打印属性值；
当fetchmode=join 时，fetch的属性值无影响。
2，fetchMode=SELECT
（1）fetch=lazy：
结果：先查询teacher表，然后打印aaa，然后打印teacher的name属性值，然后总共发出三条sql语句查询中间表teacher_class inner join class表，打印class属性值；
（2）fetch=eager：
结果：先查询teacher表，然后连续发出三条sql查询中间表teacher_class inner join class表；然后打印aaa，然后打印属性值；
3，fetchMode=SUBSELECT：
（1）fetch=lazy：
结果：先查询teacher表，然后打印aaa，然后打印teacher的name属性值，然后发出一条sql查询出满足条件的class记录，然后打印class属性值。
注意：此情况下只发出一条sql查询满足条件的class记录，用的是in关键字。
（2）fetch=eager：
结果：先查询teacher表，然后发出一条sql查询中间表teacher_class inner join class表；然后打印aaa，然后打印属性值；

总结：
（1）fetchMode=JOIN时，无论teacher表有几条记录，无论fetch是lazy还是eager，都会先发出sql把符合条件的记录都查找出来。区别在于：只有一条记录时，会通过一条sql关联所有表，多条记录时，会先查询出teacher表记录，然后连续发出多条sql查找出符合条件的class记录；因此，可以认为在fechMode=JOIN时，fetch属性失效。
（2）fetchMode=SELECT，fetch=lazy，会先查询teacher表，然后在用到class的属性的时候，才发出相应的sql查询class表，如果有多条满足条件的teacher记录，则会断续发出多条sql查询相应的中间表和class表记录。fetch=eager时，会先查询teacher表，然后发出sql查询class表记录。如果有多条满足条件的teacher表记录，则会连续发出多条sql查询中间表和class表；
（3）fetchMode=SUBSELECT，无论teacher表有几条记录，都只会发出一条sql查询中间表和class表。当fetch=lazy时，会在用到class属性的时候才发出sql；当fetch=eager时，在查询完teacher表记录后，会立即发出sql查询中间表和class表。