上一篇介绍了Hibernate持久化对象时候的级联操作。本篇介绍读取时候的级联操作。
还是用上一篇的样例。一份问卷有多个问题。可是每一个问题仅仅能属于一份问卷。
我们先看測试用例：
@Test
public void testReadFromQuestionnaire(){
Session session = sessionFactory.getCurrentSession();
session.beginTransaction();
Questionnaire qn = (Questionnaire) session.load(Questionnaire.class, 1);
System.out.println(qn.getName());
session.getTransaction().commit();
for(Question q : qn.getQuestions()){
System.out.println(q.getName());
}
}读取出Id为1的问卷，用qn表示，打印出了问卷qn的名字，最后我希望打印出qn里包括了哪些问题，想打印出问题的题干内容。
可是运行：
org.hibernate.LazyInitializationException: failed to lazily initialize a collection of role: com.ht.entity.one2manymany2one.bi.fetchcascade.Questionnaire.questions, no session or session was closed
报错了，懒载入异常，载入不到须要的实体。Questionnaire.question这个关联是没法关联上的。
那么出现这种错误的原因是：Hibernate在处理一对多关系的时候，默认是懒载入的。也就是说我从一这一方（Questionnaire）方。去读取多的一方（Question）方。是读取不到的。这么做能够减小数据库负担，可是万一我有这种需求，希望载入出多的这一方怎么做呢？代码例如以下：
@OneToMany(mappedBy="questionnaire",cascade={CascadeType.ALL},fetch=FetchType.EAGER)
public List<Question> getQuestions() {
return questions;
}在这里，配置上一个属性fetch，类型呢也是枚举，取值EAGER，这里还有另一个取值LAZY
ERGER：饥饿的，也就是立即就会载入出来
LAZY：懒的，不会载入关联对象
那么一对多默认的情况是懒载入，这里须要把fetch配置为EAGER，我们再看測试结果：
Hibernate:
select
questionna0_.id as id6_1_,
questionna0_.name as name6_1_,
questionna0_.answers as answers6_1_,
questions1_.questionnaireId as question3_3_,
questions1_.id as id3_,
questions1_.id as id7_0_,
questions1_.name as name7_0_,
questions1_.questionnaireId as question3_7_0_
from
t_questionnaire questionna0_
left outer join
t_question questions1_
on questionna0_.id=questions1_.questionnaireId
where
questionna0_.id=?
XXX公司3月转正考试
1、Java是一门OOP语言吗？A、是 B、不是
2、Java是哪个公司的作品？A、SUN B、MicroSoft看SQL语句，使用了一个left outer join将关联对象查询出来。
没问题
另一个有意思的细节，代码例如以下：
@OneToMany(mappedBy="questionnaire",cascade={CascadeType.ALL})
public List<Question> getQuestions() {
return questions;
}这里我把饥饿载入去掉。让他恢复成默认的懒载入，測试用比例如以下：
@Test
public void testReadFromQuestionnaire(){
Session session = sessionFactory.getCurrentSession();
session.beginTransaction();
Questionnaire qn = (Questionnaire) session.load(Questionnaire.class, 1);
System.out.println(qn.getName());
for(Question q : qn.getQuestions()){
System.out.println(q.getName());
}
session.getTransaction().commit();
}for循环是循环输出问卷中的问题题干的，我把for循环放在事务提交之前，再运行：
Hibernate:
select
questionna0_.id as id6_0_,
questionna0_.name as name6_0_,
questionna0_.answers as answers6_0_
from
t_questionnaire questionna0_
where
questionna0_.id=?
XXX公司3月转正考试
Hibernate:
select
questions0_.questionnaireId as question3_1_,
questions0_.id as id1_,
questions0_.id as id7_0_,
questions0_.name as name7_0_,
questions0_.questionnaireId as question3_7_0_
from
t_question questions0_
where
questions0_.questionnaireId=?
1、Java是一门OOP语言吗？A、是 B、不是
2、Java是哪个公司的作品？A、SUN B、MicroSoft
看，也载入出来了，可是这么做。不是取的关联对象，细致看SQL语句发现，首先SQL语句分开运行了，也就是从问卷表查询了一次。再去依据问卷ID去问题表查了一次，这么做就不是级联了。
那么刚才为什么for循环放在外面也能够查出来了，原因是设置了饥饿载入后，问卷对象，连带下属的问题对象一起load到了内存中，所以把session关闭后也能够读取到。所以载入的机制和差别就在这里。
以下我们看从问题读取问卷
@ManyToOne(cascade={CascadeType.ALL})
@JoinColumn(name="questionnaireId")
public Questionnaire getQuestionnaire() {
return questionnaire;
}这边不设置fetch属性。我们看測试用例：
@Test
public void testReadFromQuestion(){
Session session = sessionFactory.getCurrentSession();
session.beginTransaction();
Question q = (Question) session.load(Question.class, 1);
System.out.println(q.getName());
session.getTransaction().commit();
System.out.println(q.getName());
}读取问题Id为1的问题。打印题干和所属问卷的名称：
Hibernate:
select
question0_.id as id7_0_,
question0_.name as name7_0_,
question0_.questionnaireId as question3_7_0_
from
t_question question0_
where
question0_.id=?
Hibernate:
select
questionna0_.id as id6_1_,
questionna0_.name as name6_1_,
questionna0_.answers as answers6_1_,
questions1_.questionnaireId as question3_3_,
questions1_.id as id3_,
questions1_.id as id7_0_,
questions1_.name as name7_0_,
questions1_.questionnaireId as question3_7_0_
from
t_questionnaire questionna0_
left outer join
t_question questions1_
on questionna0_.id=questions1_.questionnaireId
where
questionna0_.id=?
1、Java是一门OOP语言吗？A、是 B、不是 XXX公司3月转正考试
没问题。说明，多对一的默认载入一这一方是EAGER的，所以不用多做设置，假设你不想载入出一这一方，那么做例如以下设置：
@ManyToOne(cascade={CascadeType.ALL},fetch=FetchType.LAZY)
@JoinColumn(name="questionnaireId")
public Questionnaire getQuestionnaire() {
return questionnaire;
}将载入机制设置为LAZY即可了。
总结一下：
在OneToMany的关系中（双向）：
从1要载入n这一方。默认是LAZY的
从n要载入1这一方，默认是EAGER的
在级联和载入机制中：
cascade仅仅是负责增，删。改的级联
而读取须要级联载入的话，要用到fetch这个属性