JPA中的failed to lazily initialize a collection of role:xxxx no session or session was closed异常分析与解决

最新推荐文章于 2024-07-04 21:07:27 发布
最新推荐文章于 2024-07-04 21:07:27 发布
阅读量1.3w 收藏 5
点赞数

引言： JPA是一种非常流行和常用的持久化框架标准，其下可以对接若干种不同的实现，在不同的父子表管理中，经常会碰到no Session的问题，该如何解决呢？

1. 问题的引出

  在进行基于JPA的单元测试中，我们使用JUnit来进行测试数据库的关联表信息读取，结果得到如下错误信息：

[html]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. org.hibernate.LazyInitializationException: failed to lazily initialize a collection of role: com.rain.wx.meal.model.DishCategory.dishes, could not initialize proxy - no Session  
  2.     at org.hibernate.collection.internal.AbstractPersistentCollection.throwLazyInitializationException(AbstractPersistentCollection.java:587)  
  3.     at org.hibernate.collection.internal.AbstractPersistentCollection.withTemporarySessionIfNeeded(AbstractPersistentCollection.java:204)  
  4.     at org.hibernate.collection.internal.AbstractPersistentCollection.initialize(AbstractPersistentCollection.java:566)  
  5.     at org.hibernate.collection.internal.AbstractPersistentCollection.read(AbstractPersistentCollection.java:135)  
  6.     at org.hibernate.collection.internal.PersistentBag.get(PersistentBag.java:449)  
  7.     at com.rain.wx.meal.service.DishServiceTest.testDishes(DishServiceTest.java:86)  
  8.     at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)  
  9.     at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)  
  10.     at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)  
  11.     at java.lang.reflect.Method.invoke(Method.java:497)  
  12.     at org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:50)  
  13.     at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:12)  
  14.     at org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:47)  
  15.     at org.junit.internal.runners.statements.InvokeMethod.evaluate(InvokeMethod.java:17)  
  16.     at org.springframework.test.context.junit4.statements.RunBeforeTestMethodCallbacks.evaluate(RunBeforeTestMethodCallbacks.java:75)  
  17.     at org.springframework.test.context.junit4.statements.RunAfterTestMethodCallbacks.evaluate(RunAfterTestMethodCallbacks.java:86)  
  18.     at org.springframework.test.context.junit4.statements.SpringRepeat.evaluate(SpringRepeat.java:84)  
  19.     at org.junit.runners.ParentRunner.runLeaf(ParentRunner.java:325)  
  20.     at org.springframework.test.context.junit4.SpringJUnit4ClassRunner.runChild(SpringJUnit4ClassRunner.java:252)  
  21.     at org.springframework.test.context.junit4.SpringJUnit4ClassRunner.runChild(SpringJUnit4ClassRunner.java:94)  
  22.     at org.junit.runners.ParentRunner$3.run(ParentRunner.java:290)  
  23.     at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:71)  
  24.     at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:288)  
  25.     at org.junit.runners.ParentRunner.access$000(ParentRunner.java:58)  
  26.     at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:268)  
  27.     at org.springframework.test.context.junit4.statements.RunBeforeTestClassCallbacks.evaluate(RunBeforeTestClassCallbacks.java:61)  
  28.     at org.springframework.test.context.junit4.statements.RunAfterTestClassCallbacks.evaluate(RunAfterTestClassCallbacks.java:70)  
  29.     at org.junit.runners.ParentRunner.run(ParentRunner.java:363)  
  30.     at org.springframework.test.context.junit4.SpringJUnit4ClassRunner.run(SpringJUnit4ClassRunner.java:191)  
  31.     at org.eclipse.jdt.internal.junit4.runner.JUnit4TestReference.run(JUnit4TestReference.java:86)  
  32.     at org.eclipse.jdt.internal.junit.runner.TestExecution.run(TestExecution.java:38)  
  33.     at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:459)  
  34.     at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:678)  
  35.     at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.run(RemoteTestRunner.java:382)  
  36.     at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.main(RemoteTestRunner.java:192)  
    经过分析，其中的关键词是： could not initialize proxy - no Session; 基于JPA的实现来分析，就是在进行数据库访问之时，当前针对数据库的访问与操作session已经关闭且释放了，故提示no Session可用。

2.  代码实现分析

    让我们来看看具体的代码吧

[html]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. @Entity  
  2. @Table(name="dish_category")  
  3. @Data  
  4. @EqualsAndHashCode(callSuper=false)  
  5. @JsonRootName(value="category")   
  6. public class DishCategory extends BaseEntity {  
  7.     private static final long serialVersionUID = -7189824224534351030L;  
  8.   
  9.     @Column  
  10.     private String name;  
  11.       
  12.     @Column  
  13.     private String description;  
  14.       
  15.       
  16.     @OneToMany  
  17.     @JoinColumn(name="category_id",referencedColumnName="id")  
  18.     private List<MealDish> dishes;  
  19. }  
  另外一个实体Bean为MealDish, 其代码为：
[html]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. @Entity  
  2. @Table(name = "dish")  
  3. @JsonRootName(value="dish")   
  4. //@Lazy(value=false)  
  5. public class MealDish extends BaseEntity {  
  6.     private static final long serialVersionUID = -3982356728880195795L;  
  7.   
  8.     @Column  
  9.     private String name;  
  10.   
  11.     @Column  
  12.     private float price;  
  13.   
  14.     @Column(name = "img_url")  
  15.     private String imgUrl;  
  16.   
  17.     @Column(name="category_id")  
  18.     private long categoryId;  
  19.   
  20.     @Column  
  21.     private boolean active;  
  22.   
  23.     // 销售数量  
  24.     @Column  
  25.     private int soldCount;  
  26.         .......  
  27. }  
其中Repository/Service的代码分别如下： 
[html]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. @Service  
  2. public class DishServiceImpl implements DishService {   
  3.        @Transactional  
  4.     @Override  
  5.     public List<DishCategory> getDishCategory() {  
  6.         return this.dishCategoryRepo.findAll();  
  7.     }  
  8.    ........  
  9.  }  
Repository相关的代码都是空代码，无实际的实现，这里再次忽略。

单元测试的代码内容：

[html]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. @Test  
  2.    public void testDishes() throws JsonProcessingException {  
  3.     ObjectMapper mapper = new ObjectMapper();  
  4.       
  5.     List<DishCategory> categories = this.dishService.getDishCategory();  
  6.       
  7.     for (DishCategory category  : categories) {  
  8.         // log.debug(String.valueOf(category.getDishes().get(0)));    
  9.     }  
  10.       
  11.     String jsonStr = mapper.writeValueAsString(categories);  
  12.       
  13.     log.info(jsonStr);  
  14.    }  
3. 问题分析

  基于对Hibernate和JPA的理解，在ORM中，其为了提升性能使用了Lazy加载，就是在使用的时候，才会加载额外的数据，故导致了在使用之时再加载数据之时， session失效的问题出现。所以问题的目标点实现提前加载数据。

4. 问题的解决

    尝试1：  在Service方法中新增了@Transactional进行事务添加

    结果1：  无效

   尝试2： 在@OneToMany的方法上，使用@Lazy(false)

    结果2：  无效

    尝试3： 在@OneToMany的参数中使用fetch=FetchType=Eager

    结果3:   问题解决

    尝试4： 在application.properties的配置文件中新增spring.jpa.open-in-view=true

    结果4： 问题解决

   方法3的正确的代码内容：

[html]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. @Entity  
  2. @Table(name="dish_category")  
  3. @Data  
  4. @EqualsAndHashCode(callSuper=false)  
  5. @JsonRootName(value="category")   
  6. public class DishCategory extends BaseEntity {  
  7.     private static final long serialVersionUID = -7189824224534351030L;  
  8.   
  9.     @Column  
  10.     private String name;  
  11.       
  12.     @Column  
  13.     private String description;  
  14.       
  15.       
  16.     @OneToMany(fetch=FetchType.EAGER)  
  17.     @JoinColumn(name="category_id",referencedColumnName="id")  
  18.     private List<MealDish> dishes;  
  19. }  

方法4的解释与说明：

   这个设置选项:

spring.jpa.open-in-view=true
  其实是之前的 openEntityManagerInViewInterceptor ，解决在Spring MVC与JPA之间Session的声明周期问题

5. 总结

    核心问题在于解决延迟加载为及时加载，及时加载会消耗一定的资源，将其程序的性能，请注意这个问题。



原博 http://blog.csdn.net/blueheart20/article/details/52912023

三分热狗
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
org.hibernate.LazyInitializationException: could not initialize proxy xxx - no Session 错误解决
oscar999的专栏
05-30 497
问题： 使用hibernate的getReference()方法时返回could not initialize proxy的错误。 发生场景： 在Spring Boot项目中测试JPA的getReference() 方法，JPA的实现是Hibernate。 @Test public void getReference() { String id= "1"; Usr usr = em.getReference(Usr.class, id); Sys
redis 在spring boot工程中的应用（三） 问题发现与解决 ：反序列化 报错
G.D.Retop的专栏
03-16 3362
问题1：序列化和反序列话问题 org.hibernate.LazyInitializationException: failed to lazily initialize a collection, could not initialize proxy - no Session 出现该问题的原因是在spring boot中使用jpa，大量使用@ManyToMany，@ManyToOne，@
JPA 中 LazyInitializationException 解决方案
小张Python
11-26 1942
JPA 中 LazyInitializationException 解决方案
failed to lazily initialize a collection of role: XXXXXXXX no session or session was closed
dizhang的专栏
07-18 2472
failed to lazily initialize a collection of role: XXXXXXXX no session or session was closed2007-05-11 10:47这个异常大致意思是说在多对一的时候（并且lazy="false"），对象的实例失败，多数出现的情况有1、粗心造成实例对象类名写错之类的2、逻辑错误如之前就已经传递过来一个
failed to lazily initialize a collection of role，解决Hibernate查询报错
最新发布
十三月的博客
07-04 1177
【extra】:一种比较聪明的懒加载策略，即调用集合的size/contains等方法的时候，hibernate并不会去加载整个集合的数据，而是发出一条聪明的SQL语句，以便获得需要的值，只有在真正需要用到这些集合元素对象数据的时候，才去发出查询语句加载所有对象的数据。【false】:取消懒加载特性，即在加载对象的同时，就发出第二条查询语句加载其关联集合的数据即加载对象的时候就发出查询语句，加载关联的子类数据。即不是不加载，而是在需要的时候才加载。什么时候用懒加载呢，我只能回答要用懒加载的时候就用懒加载。
failed to lazily initialize a collection of role问题
yanghuidang
11-07 175
今天遇到了这样一个问题 Exception in thread "main" org.hibernate.LazyInitializationException: could not initialize proxy - the owning Session was closed 在网上找了好久终于找到了一个较全的解决方法。具体如下： 　　"org.hibernate.LazyInit...
failed to lazily initialize a collection of role:XXX, no session
waj89757的专栏
06-12 984
我得程序用到了一对多关联。在查询parent时候调用了children，就报failed to lazily initialize a collection of role:XXX, no session这个错。将lazy属性改为false依然报这个错误。 在开发Struts2.0+hibernate3.2+spring2.5项目过程中，遇到了failed to lazily initial
JPA中多对多关联延迟加载问题，failed to lazily initialize a collection of role
pioneer的专栏
06-14 3560
问题场景：我使用quartz触发一个定时任务，该任务是从一个多对多的实体中关联出来数据并进行处理，由于调度的定时器每次执行都会重新实例化，所有在调度任务中无法延迟加载关联对象，此时或许去掉延迟加载可以解决这个问题，但后果是性能的大幅降低；这时考虑到的一种方案，但具有一定的适用场景，就是对数据是过滤查找即按条件查找特定数据，并非全部数据时刻考虑这种办法，其实现思路大概如下：假如A和B是多对多
org.hibernate.LazyInitializationException: failed to lazily initialize a collection of role
icecoola_的博客
04-02 1049
报错信息: description The server encountered an internal error that prevented it from fulfilling this request. exception org.springframework.http.converter.HttpMessageNotWritableException: Could not write...
关于SpringBoot中使用整合SpringData JPA，出现“No identifier specified for entity”错误及解决方法
qq_16549659的博客
02-25 1817
今天在学习springBoot整合JPA（Java Persistence API java持久层API）时，按教程中的操作运行时，控制台报错：Failed to initialize JPA EntityManagerFactory: No identifier specified for entity: com.wu.community_system.entity.Book……
JPA-failed to lazily initialize a collection of role, could not initialize proxy - no Session
ssehs的博客
05-28 1117
前言 如果有两个对象，分别时OneSide和ManySide，它们满足一对多的关系，一个OneSide对应多个ManySide。通常我们在JPA中这么定义它们的关系： @Entity public class OneSide { @OneToMany(mappedBy = "oneSide") private Set<ManySide> manySides; } @Entity public class ManySide { @ManyToOne @JoinColumn p
解决： failed to lazily initialize a collection of role: no session or session was closed问题
说：/~不了的专栏
08-18 3490
org.hibernate.LazyInitializationException: failed to lazily initialize a collection of role: cn.itcast.domain.User.posts, no session or session was closed
【开发心得】jpa failed to lazily initialize a collection of role
清风唱诗人的博客
06-01 797
jpa: hibernate: # 生产环境设置成 none，避免程序运行时自动更新数据库结构 ddl-auto: update properties: hibernate: dialect: org.hibernate.dialect.MySQL5InnoDBDialect format_sql: true # 出现no session 请把这个配置设置为true open-in-view: false ...
failed to lazily initialize a collection of role: ......, no session or session was closed
C.
03-01 1763
我在用ssh框架编写图书管理系统的时候遇到了这样的错误org.hibernate.LazyInitializationException: failed to lazily initialize a collection of role: com.cc.library.domain.Reader.borrowInfos, no session or session was closed at
failed to lazily initialize a collection of role:XXX, no sessi拒绝方法
Jeffrey‘s workspace
10-21 5460
failed to lazily initialize a collection of role: com.ccy.valueBean.Coustomer.accounts, no session or session was closed 1、设置lazy=false 如果是用annotation，则配置如下 @OneToMany(    targetEntity = CourseA
failed to lazily initialize a collection of role: no session or session was closed (Hibernate) 解决...
yangshen998
12-15 202
在学着编写OA 权限管理时，在jsp 页面中通过已取得的 父模块来获取该模块的所有子模块 JSP 代码片段： &lt;c:forEach items="${modules}" var="module"&gt; &lt;c:forEach items="${module.children}" var="child"&gt; &lt;td&gt; ${c
failed to lazily initialize a collection of role: could not initialize proxy - no Session
二次加工是一种痛
07-21 3388
hibernate 中，在关联一对多时，默认懒加载，只会取dangqian
failed to lazily initialize a collection of role: , could not initialize proxy - no Session
weixin_33932129的博客
01-23 212
hibernate 报错信息如下: 严重: Servlet.service() for servlet [spring2] in context with path [/convention] threw exception [Request processing failed; nested exception is org.h...
JPA多线程下懒加载No session怎么处理及其解决及其代码
05-26
在多线程环境下，如果使用JPA的懒加载机制，可能会出现“No session”错误。这是因为每个线程都有自己的事务和Session，当一个线程查询到一个懒加载属性时，它会尝试从自己的Session中加载该属性，但是由于该Session已经关闭了，就会出现“No session”错误。 解决该问题的方法有两种： 1. 使用EAGER加载方式替代懒加载 将懒加载属性改为EAGER加载方式，这样在查询主实体时就会同时查询加载所有关联实体的数据，避免了在后续使用时出现“No session”错误。但是这种方式可能会导致性能问题，因为EAGER加载会一次性加载所有关联实体的数据，如果关联实体数据量很大，可能会导致查询性能下降。 2. 在每个线程中重新打开Session 在每个线程中重新打开Session，这样就可以保证每个线程都能访问到自己的Session，避免了“No session”错误。可以使用ThreadLocal来保存每个线程的Session，保证线程安全。示例代码如下： ``` public class JpaUtil { private static ThreadLocal<EntityManager> threadLocal = new ThreadLocal<>(); public static EntityManager getEntityManager() { EntityManager entityManager = threadLocal.get(); if (entityManager == null) { entityManager = EntityManagerFactoryHolder.getEntityManagerFactory().createEntityManager(); threadLocal.set(entityManager); } return entityManager; } public static void closeEntityManager() { EntityManager entityManager = threadLocal.get(); if (entityManager != null) { entityManager.close(); threadLocal.remove(); } } } ``` 使用时，在每个线程中打开和关闭Session： ``` public void doInNewThread() { JpaUtil.getEntityManager().getTransaction().begin(); // 查询主实体，关联实体使用懒加载 MainEntity mainEntity = JpaUtil.getEntityManager().find(MainEntity.class, 1L); // 加载关联实体 Hibernate.initialize(mainEntity.getLazyEntity()); JpaUtil.getEntityManager().getTransaction().commit(); JpaUtil.closeEntityManager(); } ``` 这样就可以在多线程环境下使用JPA的懒加载机制了。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值