如何解决“懒惰初始化角色集合失败”Hibernate异常答案

【问题标题】：How to solve the “failed to lazily initialize a collection of role” Hibernate exception如何解决“懒惰初始化角色集合失败”Hibernate异常
【发布时间】：2012-07-29 14:19:13
【问题描述】：

我有这个问题：

org.hibernate.LazyInitializationException: 延迟初始化角色集合失败：mvc3.model.Topic.cmets，没有会话或会话关闭

这是模型：

@Entity
@Table(name = "T_TOPIC")
public class Topic {

    @Id
    @GeneratedValue(strategy=GenerationType.AUTO)
    private int id;

    @ManyToOne
    @JoinColumn(name="USER_ID")
    private User author;

    @Enumerated(EnumType.STRING)    
    private Tag topicTag;

    private String name;
    private String text;

    @OneToMany(mappedBy = "topic", cascade = CascadeType.ALL)
    private Collection<Comment> comments = new LinkedHashSet<Comment>();

    ...

    public Collection<Comment> getComments() {
           return comments;
    }

}

调用模型的控制器如下所示：

@Controller
@RequestMapping(value = "/topic")
public class TopicController {

    @Autowired
    private TopicService service;

    private static final Logger logger = LoggerFactory.getLogger(TopicController.class);


    @RequestMapping(value = "/details/{topicId}", method = RequestMethod.GET)
    public ModelAndView details(@PathVariable(value="topicId") int id)
    {

            Topic topicById = service.findTopicByID(id);
            Collection<Comment> commentList = topicById.getComments();

            Hashtable modelData = new Hashtable();
            modelData.put("topic", topicById);
            modelData.put("commentList", commentList);

            return new ModelAndView("/topic/details", modelData);

     }

}

jsp 页面如下所示：

<%@page import="com.epam.mvc3.helpers.Utils"%>
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<%@ page session="false" %>
<html>
<head>
      <title>View Topic</title>
</head>
<body>

<ul>
<c:forEach items="${commentList}" var="item">
<jsp:useBean id="item" type="mvc3.model.Comment"/>
<li>${item.getText()}</li>

</c:forEach>
</ul>
</body>
</html>

查看jsp时出现异常。在与 c:forEach 循环

的行中

【问题讨论】：

标签： java spring hibernate jsp spring-mvc

【解决方案1】：

如果您知道每次检索Topic 时都希望查看所有Comments，则将comments 的字段映射更改为：

@OneToMany(fetch = FetchType.EAGER, mappedBy = "topic", cascade = CascadeType.ALL)
private Collection<Comment> comments = new LinkedHashSet<Comment>();

默认情况下，集合是延迟加载的，如果您想了解更多信息，请查看this。

【讨论】：

抱歉，我想使用延迟加载。因此，我将“LinkedHashSet”类型更改为“PersistentList”。异常依然发生
这可以用作解决方法，但不是问题的实际解决方案。如果我们需要延迟获取怎么办？
但如果我们想要懒惰，那么这个解决方案将不起作用，而且大多数情况下我们只想要懒惰。
这是在堆栈溢出时到处弹出的答案类型。简而言之，解决问题和误导。对于未来的读者，请帮自己一个忙，了解究竟什么是懒惰和急切地获取，并了解其后果。
@darrengorman 当我开始 JPA 时，我围绕 OP 的问题发布了一个问题。我收到了和你一样的回复。很快，当我进行了数十万行的测试时，猜猜发生了什么？我认为它具有误导性，因为它为大多数初学者将面临的问题提供了过于简单的答案，并且如果他们不小心，他们很快就会将整个数据库加载到内存中（他们不会，因为他们不会请注意）:)。

【解决方案2】：

根据我的经验，我有以下方法来解决著名的 LazyInitializationException：

(1) 使用 Hibernate.initialize

Hibernate.initialize(topics.getComments());

(2) 使用 JOIN FETCH

您可以在 JPQL 中使用 JOIN FETCH 语法来显式提取子集合。这有点像 EAGER fetching。

(3) 使用 OpenSessionInViewFilter

LazyInitializationException 经常发生在视图层。如果你使用 Spring 框架，你可以使用 OpenSessionInViewFilter。但是，我不建议您这样做。如果使用不当，可能会导致性能问题。

【讨论】：

(1) 非常适合我。我的情况：Hibernate.initialize(registry.getVehicle().getOwner().getPerson().getAddress());
Hibernate.initialize 似乎不适用于EntityManager
这应该是正确的答案。例如，在我的工作项目中，我们明确不应该使用 EAGER 获取。它会导致这个特定系统出现问题。
看起来很有吸引力，但在另一种情况下缺乏实施文档...您能否提供更多链接或说明如何实施此解决方案？

【解决方案3】：

我知道这是一个老问题，但我想提供帮助。你可以把事务注解放在你需要的服务方法上，在这种情况下 findTopicByID(id) 应该有

@Transactional(propagation=Propagation.REQUIRED, readOnly=true, noRollbackFor=Exception.class)

关于这个注解的更多信息可以找到here

关于其他解决方案：

fetch = FetchType.EAGER

不是一个好习惯，只有在必要时才应该使用它。

Hibernate.initialize(topics.getComments());

休眠初始化程序将您的类绑定到休眠技术。如果您的目标是灵活，则不是一个好方法。

希望对你有帮助

【讨论】：

@Transactional 注释对我有用，但请注意 Propagation.REQUIRED 是默认值，至少在 Spring Boot 1.4.2（Spring 4.3）中是这样。
是的，但我认为可以明确说明您实际上可以更改传播参数
@Transactional 不是 Spring 独有的吗？
@Campa 是的。如果您想手动处理它，您应该将您的业务逻辑放在从实体管理器检索的事务中
我不确定我是否理解为什么这可以解决我的问题，但确实如此。谢谢！

【解决方案4】：

问题的根源：

默认情况下，休眠会延迟加载集合（关系），这意味着无论何时您在代码中使用collection（此处为comments 字段在Topic 类） hibernate 从数据库中获取它，现在的问题是您正在控制器中获取集合（其中 JPA 会话已关闭）。这是导致异常的代码行（您正在加载comments 集合）：

    Collection<Comment> commentList = topicById.getComments();

您在控制器中获得“cmets”集合 (topic.getComments())（JPA session 已结束），这会导致异常。另外，如果你有你的 jsp 文件中的 comments 集合是这样的（而不是在你的控制器中获取它）：

<c:forEach items="topic.comments" var="item">
//some code
</c:forEach>

出于同样的原因，您仍然会遇到同样的例外情况。

解决问题：

因为在一个实体类中你只能有两个带有FetchType.Eager(eagerly fetched collection) 的集合，并且因为延迟加载更多比热切加载更有效，我认为这种解决问题的方法比将FetchType 更改为热切要好：

如果你想让集合惰性初始化，并让它工作，最好将此 sn-p 代码添加到您的 web.xml 中：

<filter>
    <filter-name>SpringOpenEntityManagerInViewFilter</filter-name>
    <filter-class>org.springframework.orm.jpa.support.OpenEntityManagerInViewFilter</filter-class>
</filter>
<filter-mapping>
    <filter-name>SpringOpenEntityManagerInViewFilter</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

这段代码的作用是增加JPA session 的长度，或者如文档所述，使用"to allow for lazy loading in web views despite the original transactions already being completed." 所以这样，JPA 会话将打开更长的时间，因此您可以在 jsp 文件和控制器类中延迟加载集合。

【讨论】：

为什么 JPS 会话关闭？如何让它不被关闭？如何进行惰性收集？
什么定义了每个实体两个 FetchType.Eager 集合的限制？
在 Spring Boot 中，可以将 'spring.jpa.open-in-view=true' 添加到 'application.properties'

【解决方案5】：

@Controller
@RequestMapping(value = "/topic")
@Transactional

我通过添加@Transactional来解决这个问题，我认为这可以使会话打开

【讨论】：

为什么这会得到负票？向操作中添加事务会扩展会话
向控制器添加@Transactional 是不好的做法。
@Rafael 为什么这是一个不好的做法？
@AmrEllafy -> 这是一个很好的解释：stackoverflow.com/a/18498834/1261162
@JeSuisAlrick 整个网站均基于专业建议。我的专业建议是避免提出的解决方案并将其视为一种不好的做法，并且我指出了一个非常明确的解释。当然，任何人都可以不同意这一点。如果你不想接受这个解释，因为它不是来自 Spring，那是你的决定。其他人可能同意也可能不同意您的看法。但我必须投减票，因为我真的认为这是一个误导性的答案。

【解决方案6】：

原因是当你使用延迟加载时，会话被关闭了。

有两种解决方案。

不要使用延迟加载。

在 XML 中设置 lazy=false 或在注释中设置 @OneToMany(fetch = FetchType.EAGER)。
使用延迟加载。

在 XML 中设置 lazy=true 或在注释中设置 @OneToMany(fetch = FetchType.LAZY)。

并在您的web.xml 中添加OpenSessionInViewFilter filter

详情见我的POST。

【讨论】：

... 但这两种解决方案都不好。建议使用 EAGER 会产生巨大的问题。使用 OpenSessionInViewFilter 是一种反模式。

【解决方案7】：

问题是由于在休眠会话关闭的情况下访问属性引起的。您在控制器中没有休眠事务。

可能的解决方案：

在服务层（使用@Transactional）而不是在控制器中执行所有这些逻辑。应该有正确的地方来执行此操作，它是应用程序逻辑的一部分，而不是在控制器中（在这种情况下，是加载模型的接口）。服务层中的所有操作都应该是事务性的。即：将此行移至 TopicService.findTopicByID 方法：

集合commentList = topicById.getComments();
使用“渴望”而不是“懒惰”。现在你没有使用'lazy' .. 这不是一个真正的解决方案，如果你想使用lazy，就像一个临时（非常临时）的解决方法。
在控制器中使用@Transactional。它不应该在这里使用，您将服务层与表示混合在一起，这不是一个好的设计。
使用 OpenSessionInViewFilter，报告了许多缺点，可能不稳定。

一般来说，最好的解决方案是 1.

【讨论】：

Eager 的 Fetch 类型假设 hibernate 会在第一个查询中拉取所有数据，而不是所有地方都正确
你应该大写最好的解决方案是 1 ...事实上是唯一好的解决方案，因为所有其他都是反模式！
我同意@Rafael 唯一的解决方案是第一个

【解决方案8】：

处理LazyInitializationException 的最佳方法是在查询时获取它，如下所示：

select t
from Topic t
left join fetch t.comments

您应该始终避免以下反模式：

FetchType.EAGER
OSIV (Open Session in View)
hibernate.enable_lazy_load_no_trans Hibernate configuration property

因此，请确保您的 FetchType.LAZY 关联在查询时或在原始 @Transactional 范围内使用 Hibernate.initialize 进行二次集合初始化。

【讨论】：

Vlad 对于在 Spring 生成的存储库的 findById() 方法获取的实体中使用惰性初始化集合，您有什么建议吗？我没有编写查询，并且事务在我的代码之外。
您能否澄清“在原始@Transactional 范围内”的意思？这对我来说不清楚，因为我似乎在公开会话中遇到了这个错误（但不是正确的？）跨度>
在顶级事务服务方法的范围内，也称为事务网关。查看堆栈跟踪中的TrassctionInterceptor，就是这样。
迄今为止最好的答案之一......这应该标记为正确。顺便说一句...假设 OSIV 是一种反模式，如何在 spring-boot 最新版本上默认启用？ ......也许不是那么糟糕？
当然，这很糟糕。从 Spring Boot 2 开始，a warning is logged telling you to disable it.

【解决方案9】：

为了延迟加载集合，必须有一个活动会话。在 Web 应用程序中，有两种方法可以做到这一点。您可以使用Open Session In View 模式，其中使用interceptor 在请求开始时打开会话并在结束时关闭它。存在的风险是您必须进行可靠的异常处理，否则您可能会绑定所有会话并且您的应用程序可能会挂起。

处理此问题的另一种方法是在控制器中收集您需要的所有数据，关闭会话，然后将数据填充到模型中。我个人更喜欢这种方法，因为它似乎更接近 MVC 模式的精神。此外，如果您以这种方式从数据库中收到错误，您可以比在视图渲染器中更好地处理它。在这种情况下，您的朋友是Hibernate.initialize(myTopic.getComments())。您还必须将对象重新附加到会话，因为您正在为每个请求创建一个新事务。为此使用 session.lock(myTopic,LockMode.NONE)。

【讨论】：

【解决方案10】：

最好的解决方案之一是在 application.properties 文件中添加以下内容： spring.jpa.properties.hibernate.enable_lazy_load_no_trans=true

【讨论】：

你能告诉 OP 它到底做了什么，有什么副作用，性能影响吗？
在延迟加载的后面，每次延迟加载关联时都会分叉一个新会话，因此会分叉更多的连接，并对连接池造成一点压力。如果您对连接数有限制，那么此属性可能不适合使用。
对于某些人来说，它被认为是一种反模式vladmihalcea.com/…

【解决方案11】：

如果您试图在实体和 Collection 或 Java 对象列表（例如 Long 类型）之间建立关系，它会像这样：

@ElementCollection(fetch = FetchType.EAGER)
    public List<Long> ids;

【讨论】：

在很多情况下，您真的不想这样做。您在这里失去了延迟加载的所有好处

【解决方案12】：

fetch = FetchType.LAZY 应该有两件事。

@Transactional

和

Hibernate.initialize(topicById.getComments());

【讨论】：

非常感谢兄弟。我正好找到了第二块 :)

【解决方案13】：

这个延迟初始化问题有多种解决方案 -

1) 将关联 Fetch 类型从 LAZY 更改为 EAGER，但这不是一个好的做法，因为这会降低性能。

2) 在关联对象上使用 FetchType.LAZY 并在服务层方法中使用 Transactional 注释，以便会话保持打开状态，当您调用 topicById.getComments() 时，将加载子对象 (cmets)。

3) 另外，请尝试在控制器层使用 DTO 对象而不是实体。在您的情况下，会话在控制器层关闭。所以最好在服务层将实体转换为 DTO。

【讨论】：

【解决方案14】：

我发现将@PersistenceContext 声明为EXTENDED 也可以解决这个问题：

@PersistenceContext(type = PersistenceContextType.EXTENDED)

【讨论】：

您好，请注意此类更改。 TRANSACTION 范围的持久性上下文创建是惰性的，这是 OP 的意图。所以问题是你是否想成为无国籍人。此设置取决于系统的用途，不应该太……急切地更改。如果你明白我的意思。在这里阅读stackoverflow.com/questions/2547817/…
危险。这不是正确的答案。上面还有其他更准确和安全的方法。

【解决方案15】：

您的列表是延迟加载的，因此未加载该列表。打电话上榜是不够的。在 Hibernate.initialize 中使用以初始化列表。如果在列表元素上运行 dosnt 工作并为每个 . 这需要在您从事务范围返回之前。看看this 的帖子。
搜索 -

Node n = // .. get the node
Hibernate.initialize(n); // initializes 'parent' similar to getParent.
Hibernate.initialize(n.getChildren()); // pass the lazy collection into the session

【讨论】：

【解决方案16】：

这是我最近遇到的问题，我用

解决了

<f:attribute name="collectionType" value="java.util.ArrayList" />

更详细的描述here 这节省了我的时间。

【讨论】：

【解决方案17】：

为了解决我的问题，它只是缺少这一行

<tx:annotation-driven transaction-manager="myTxManager" />

在应用程序上下文文件中。

未考虑方法上的 @Transactional 注释。

希望答案对某人有所帮助

【讨论】：

【解决方案18】：

控制器上的@Transactional 注释丢失

@Controller
@RequestMapping("/")
@Transactional
public class UserController {
}

【讨论】：

我认为事务管理属于业务逻辑所在的服务层。
事务注释没有丢失。控制器不应该有这样的注释。这些注释应该处于服务级别。

【解决方案19】：

通过使用 hibernate @Transactional 注释，如果您从数据库中获取具有延迟获取属性的对象，您可以通过获取这些属性来简单地获取这些属性，如下所示：

@Transactional
public void checkTicketSalePresence(UUID ticketUuid, UUID saleUuid) {
        Optional<Ticket> savedTicketOpt = ticketRepository.findById(ticketUuid);
        savedTicketOpt.ifPresent(ticket -> {
            Optional<Sale> saleOpt = ticket.getSales().stream().filter(sale -> sale.getUuid() == saleUuid).findFirst();
            assertThat(saleOpt).isPresent();
        });
}

在这里，在 Hibernate 代理管理的事务中，调用 ticket.getSales() 的事实会执行另一个查询以获取销售额，因为您明确要求它。

【讨论】：

【解决方案20】：

问题是因为当关闭与数据库的“连接”时代码正在访问惰性 JPA 关系（持久性上下文是 Hibernate/JPA 的正确名称）。

在 Spring Boot 中解决它的一个简单方法是定义一个服务层并使用 @Transactional 注释。方法中的此注释创建了一个事务，该事务传播到存储库层并保持打开持久性上下文，直到方法完成。如果您访问事务方法中的集合，Hibernate/JPA 将从数据库中获取数据。

在您的情况下，您只需要在您的TopicService 中使用@Transactional 方法findTopicByID(id) 进行注释，并在该方法中强制获取集合（例如，通过询问其大小）：

    @Transactional(readOnly = true)
    public Topic findTopicById(Long id) {
        Topic topic = TopicRepository.findById(id).orElse(null);
        topic.getComments().size();
        return topic;
    }

【讨论】：

【解决方案21】：

在第二次执行生成 JWT 令牌的方法后出现此错误。

user.getUsersRole().stream().forEachOrdered((ur) -> roles.add(ur.getRoleId())); 行产生了错误。

// MyUserDetails.java

@Service
public class MyUserDetails implements UserDetailsService {

  @Override
  public UserDetails loadUserByUsername(String email) {

    /* ERROR
    /* org.hibernate.LazyInitializationException: failed to 
    /* lazily initialize a collection of role: 
    /* com.organizator.backend.model.User.usersRole, 
    /* could not initialize proxy - no Session */
    user.getUsersRole().stream().forEachOrdered((ur) ->
           roles.add(ur.getRoleId()));

在我的情况下，@Transacctional 注释解决了它，

// MyUserDetails.java

import org.springframework.transaction.annotation.Transactional;

@Service
public class MyUserDetails implements UserDetailsService {

  @Override
  @Transactional // <-- added
  public UserDetails loadUserByUsername(String email) {

    /* No Error */
    user.getUsersRole().stream().forEachOrdered((ur) ->
           roles.add(ur.getRoleId()));

【讨论】：

您能告诉我为什么@Transactional 解决了这个问题吗？

【解决方案22】：

对于那些使用Criteria 的人，我发现

criteria.setFetchMode("lazily_fetched_member", FetchMode.EAGER);

做了我需要做的一切。

集合的初始获取模式设置为 FetchMode.LAZY 以提供性能，但是当我需要数据时，我只需添加该行并享受完全填充的对象。

【讨论】：

【解决方案23】：

在我的情况下，以下代码是一个问题：

entityManager.detach(topicById);
topicById.getComments() // exception thrown

因为它已从数据库中分离出来，并且 Hibernate 在需要时不再从字段中检索列表。所以我在分离之前初始化它：

Hibernate.initialize(topicById.getComments());
entityManager.detach(topicById);
topicById.getComments() // works like a charm

【讨论】：

【解决方案24】：

不是最好的解决方案，但对于那些面临LazyInitializationException 尤其是Serialization 的人来说，这会有所帮助。在这里，您将检查延迟初始化的属性并将null 设置为这些属性。为此创建以下类

public class RepositoryUtil {
    public static final boolean isCollectionInitialized(Collection<?> collection) {
        if (collection instanceof PersistentCollection)
            return ((PersistentCollection) collection).wasInitialized();
        else 
            return true;
    }   
}

在您拥有延迟初始化属性的 Entity 类中，添加如下所示的方法。在此方法中添加所有延迟加载属性。

public void checkLazyIntialzation() {
    if (!RepositoryUtil.isCollectionInitialized(yourlazyproperty)) {
        yourlazyproperty= null;
    }

在您加载数据的所有位置之后调用此checkLazyIntialzation() 方法。

 YourEntity obj= entityManager.find(YourEntity.class,1L);
  obj.checkLazyIntialzation();

【讨论】：

【解决方案25】：

为了摆脱惰性初始化异常，您在操作分离对象时不应调用惰性收集。

在我看来，最好的方法是使用 DTO，而不是实体。在这种情况下，您可以明确设置要使用的字段。像往常一样就足够了。不用担心 Lombok 生成的诸如 jackson ObjectMapper 或 hashCode 之类的东西会隐式调用您的方法。

对于某些特定情况，您可以使用@EntityGrpaph 注释，即使您的实体中有fetchType=lazy，它也允许您加载eager。

【讨论】：

【解决方案26】：

这是一个老问题，但以下信息可能会帮助人们寻找答案。

@VladMihalcea 的回答很有用。您不能依赖 FetchType.EAGER ，而应在需要时将 cmets 加载到 Topic 实体中。

如果您没有明确定义查询以便可以指定 join fetch，则使用 @NamedEntityGraph 和 @EntityGraph 您可以覆盖 FetchType.LAZY（@OneToMany 关联使用LAZY 默认）在运行时并与 Topic 同时加载 cmets 仅在需要时。这意味着您将加载 cmets 仅限于那些真正需要的方法（查询）。一个实体图为 JPA defines it：

实体图可以与 find 方法一起使用，也可以用作查询提示覆盖或增加 FetchType 语义。

您可以根据 JPA 示例 here 使用它。或者，如果您使用 Spring Data JPA，那么您可以根据示例 provided by Spring 使用它。

【讨论】：

【解决方案27】：

原因是您试图在关闭服务内的会话后获取控制器上的 commentList。

topicById.getComments();

只有当你的休眠会话处于活动状态时，上面才会加载评论列表，我猜你在服务中关闭了。

因此，您必须在关闭会话之前获取 commentList。

【讨论】：

是的，这是问题陈述，您还应该在Answer中提供答案

【解决方案28】：

模型类Topic 中的集合comments 是延迟加载的，如果您没有专门使用fetch = FetchType.EAGER 注释它，这是默认行为。

您的findTopicByID 服务很可能正在使用无状态休眠会话。 A stateless session 没有一级缓存，即没有持久化上下文。稍后当您尝试迭代 comments 时，Hibernate 将抛出异常。

org.hibernate.LazyInitializationException: failed to lazily initialize a collection of role: mvc3.model.Topic.comments, no session or session was closed

解决办法可以是：

用fetch = FetchType.EAGER注释comments

@OneToMany(fetch = FetchType.EAGER, mappedBy = "topic", cascade = CascadeType.ALL)   
private Collection<Comment> comments = new LinkedHashSet<Comment>();

如果您仍然希望 cmets 被延迟加载，请使用 Hibernate's stateful sessions，以便您稍后能够按需获取 cmets。

【讨论】：

【解决方案29】：

就我而言，我有 b/w A 和 B 之类的映射

A有

@OneToMany(mappedBy = "a", cascade = CascadeType.ALL)
Set<B> bs;

在DAO 层中，如果您没有使用Fetch Type - Eager注释映射，则需要使用@Transactional 注释方法 >

【讨论】：

【解决方案30】：

嗨，所有发布都很晚希望它可以帮助别人，提前感谢@GMK 提供这篇文章Hibernate.initialize(object)

当 Lazy="true"

Set<myObject> set=null;
hibernateSession.open
set=hibernateSession.getMyObjects();
hibernateSession.close();

现在如果我在关闭会话后访问“设置”，它会引发异常。

我的解决方案：

Set<myObject> set=new HashSet<myObject>();
hibernateSession.open
set.addAll(hibernateSession.getMyObjects());
hibernateSession.close();

现在我可以在关闭 Hibernate Session 之后访问“set”。

【讨论】：