Hibernate级联操作和载入机制(二) cascade and fetch

本文深入探讨Hibernate在处理一对多与多对一时的级联操作与载入机制,包括懒载入与饥饿载入的区别,以及如何在查询时确保关联对象被正确加载。通过实例分析,详细解释了如何配置fetch属性来实现一对多关系的饥饿载入,以及多对一关系默认的饥饿载入机制。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

上一篇介绍了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这个属性

转载于:https://www.cnblogs.com/zfyouxi/p/5175663.html

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值