相关疑难解决方法(0)

我有这个问题:

org.hibernate.LazyInitializationException:懒得初始化角色集合:mvc3.model.Topic.comments,没有会话或会话被关闭

这是模型:

@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 …

我得到以下异常:

Exception in thread "main" org.hibernate.LazyInitializationException: could not initialize proxy - no Session
    at org.hibernate.proxy.AbstractLazyInitializer.initialize(AbstractLazyInitializer.java:167)
    at org.hibernate.proxy.AbstractLazyInitializer.getImplementation(AbstractLazyInitializer.java:215)
    at org.hibernate.proxy.pojo.javassist.JavassistLazyInitializer.invoke(JavassistLazyInitializer.java:190)
    at sei.persistence.wf.entities.Element_$$_jvstc68_47.getNote(Element_$$_jvstc68_47.java)
    at JSON_to_XML.createBpmnRepresantation(JSON_to_XML.java:139)
    at JSON_to_XML.main(JSON_to_XML.java:84)

当我尝试从main调用以下行时:

Model subProcessModel = getModelByModelGroup(1112);
System.out.println(subProcessModel.getElement().getNote());

我getModelByModelGroup(int modelgroupid)首先实现了这个方法,如下所示:

public static Model getModelByModelGroup(int modelGroupId, boolean openTransaction) {

    Session session = SessionFactoryHelper.getSessionFactory().getCurrentSession();     
    Transaction tx = null;

    if (openTransaction) {
        tx = session.getTransaction();
    }

    String responseMessage = "";

    try {
        if (openTransaction) {
            tx.begin();
        }
        Query query = session.createQuery("from Model where modelGroup.id = :modelGroupId");
        query.setParameter("modelGroupId", modelGroupId); …

我在Spring Boot文档中看到了JPA配置的这个属性spring.jpa.open-in-view=true.那么它被设置为true,它是默认值吗？

它到底意味着什么？我没有找到任何解释这种行为.

它应该是使用Hibernate SessionFactory来代替EntityManagerFactory？如果是,我该如何设置EntityManagerFactory？

感谢任何帮助.

谢谢!

即使在创建实体管理器的实体管理器不再可用之后,EclipseLink也可以在实体中加载延迟关系.使用Hibernate 这不起作用,或者至少在该帖子时没有.

其他提供商怎么样？特别是OpenJPA和DataNucleus？

这有什么缺点(除了更复杂的实现)？

几个月来,我的Web应用程序运行顺利,但在过去一两周内,它一直在断开与MySQL服务器的连接.我不是DBA的人,也不知道如何调试它.

这就是我所知道的:

1. 连接似乎每隔几个小时就会消失.有时在白天,但总是在夜间.
2. 我的实验室有一台MySQL服务器,可托管多个应用程序的数据库
3. 目前,我们与MySQL服务器有46个连接.
4. 据我所知,没有其他应用程序遇到此问题.
5. 我的应用程序使用相同的堆栈,配置甚至代码连接到数据库作为另一个应用程序 - 这个其他应用程序每天支持大约200个用户,并且自2013年以来一直运行顺利.

6. 两个应用程序都使用Hibernate ORM; 这是我所知道的唯一配置:

   <!-- TomcatJDBCConnectionProvider class is common to both applications -->
   <property name="hibernate.connection.provider_class">org.hibernate.connection.TomcatJDBCConnectionProvider</property>
   <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
   <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
   <property name="hibernate.connection.pool_size">5</property>
   <property name="hibernate.current_session_context_class">thread</property>
   <property name="hibernate.tomcatJdbcPool.validationQuery">SELECT 1</property>
   <property name="hibernate.tomcatJdbcPool.testOnBorrow">true</property>
   <property name="hibernate.enable_lazy_load_no_trans">true</property>
   

   Run Code Online (Sandbox Code Playgroud)

7. 该问题与有人试图使用应用程序的RESTful API下载数据的时间大致相同.这个用户 - 实际上是一个协作者 - 有一个小脚本迭代特定表中的每一行并请求所有元数据.

8. 这个问题也开始于我的实验室开始提供Coursera大规模开放在线课程的同时.我不知道这些数字是什么,但网站上的实际使用量必须已经增加.

我知道这是一个广泛的问题,但我真的不知道如何调试这个.任何建议表示赞赏.

编辑:

围绕其他应用程序挖掘ServletContextListener,我找到了我的contextDestroyed函数没有的代码:

// TODO: Find memory leak that requires server to be restarted after hot deploying several (3?) times.
Set<Thread> threadSet = Thread.getAllStackTraces().keySet();
for (Thread t : threadSet) {
    if …

希望听听有关从JSF UI编辑JPA实体的最佳实践的专家.

所以,关于这个问题的几句话.

想象一下,我有持久化对象MyEntity,我将其取出进行编辑.在DAO层我使用

return em.find(MyEntity.class, id);

MyEntity在"父"实体上返回带有代理的实例 - 想象其中一个是MyParent.MyParent被提取为代理问候语@Access(AccessType.PROPERTY):

@Entity
public class MyParent {

    @Id
    @Access(AccessType.PROPERTY)    
    private Long id;
    //...
}

和MyEntity有它的参考:

@ManyToOne(fetch = FetchType.LAZY)
@LazyToOne(LazyToOneOption.PROXY)
private MyParent myParent;

到现在为止还挺好.在UI中,我只是直接使用获取的对象而不创建任何值对象,并使用选择列表中的父对象:

<h:selectOneMenu value="#{myEntity.myParent.id}" id="office">
    <f:selectItems value="#{parents}"/>
</h:selectOneMenu>

一切都好,没有LazyInitializationException发生.但是当我保存对象时,我收到了

LazyInitializationException: could not initialize proxy - no Session

在MyParent代理setId()方法.

如果我改变MyParent关系,我可以轻松解决问题EAGER

@ManyToOne(fetch = FetchType.EAGER)
private MyParent myParent;

或使用获取对象left join fetch p.myParent(实际上我现在这样做).在这种情况下,保存操作正常,并且关系MyParent透明地更改为新对象.不需要执行其他操作(手动复制,手动参考设置).非常简单方便. …

我完全糊涂了,我一直用hibernate创建我的第一个Spring应用程序,当我从数据库中延迟加载对象时,我似乎无法发现我的错误.

我的模型如下

团队课

@Entity
public class Team {

    @Id
    @Column
    @GeneratedValue(strategy=GenerationType.AUTO)
    private int id;
    @Column
    private String name;
    @Column
    private String description;

    @OneToMany(fetch=FetchType.LAZY , cascade = CascadeType.ALL, mappedBy="team")
    @JsonIgnore
    public List<Person> members;

    //Constructors and setters getters ommited
}

人类

@Entity
@Table(name="`person`")
public class Person {

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

    @ManyToOne(fetch=FetchType.LAZY)
    @JoinColumn(name="team")
    @JsonIgnore
    private Team team;

    //omitted constructor and methods
}

然后我有我的数据访问对象,它们都遵循相同的模式

@Repository
public class TeamDaoImpl implements TeamDao {

    @Autowired
    private SessionFactory session;

    @Override
    public …

我正在开发一个Struts2 + Spring + Hibernate webapp,我需要在检索一个对象或该对象的集合后初始化一个惰性集合.

用例

我有一个团队模型,其中一个关系急切地被称为员工(我认为很明显这是一个集合).反过来,员工模型有一个懒惰的关系注册表,我只需要一些特定的操作,所以我根本不需要急切地加载它.

现在.我打电话给我teamService(用Spring注入我的Struts2控制器),以便检索teamItem已经加载了他的收集员工的特定信息.现在是时候为每个员工加载其注册表关系了.

使用employeeService(也用Spring注入我的Struts2控制器)我调用initializeCollections()他的DAO方法,该方法应加载延迟集合调用

Hibernate.initialize(employee.getRegistry());

当我执行此操作时,org.hibernate.LazyInitializationException: could not initialize proxy - no Session会抛出异常.

堆栈跟踪:

at org.hibernate.proxy.AbstractLazyInitializer.initialize(AbstractLazyInitializer.java:167) ~[hibernate-core-3.6.10.Final.jar:3.6.10.Final]
at org.hibernate.Hibernate.initialize(Hibernate.java:414) ~[hibernate-core-3.6.10.Final.jar:3.6.10.Final]
at web.bkgd.simba.dao.registry.RegistryEmployeeDAO.initializeCollections(RegistryEmployeeDAO.java:438) ~[RegistryEmployeeDAO.class:?]
at web.bkgd.simba.service.abstractions.BaseService.initializeCollections(BaseService.java:142) ~[BaseService.class:?]
at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) ~[?:1.7.0_79]
at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:57) ~[?:1.7.0_79]
at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) ~[?:1.7.0_79]
at java.lang.reflect.Method.invoke(Method.java:606) ~[?:1.7.0_79]
at org.springframework.aop.support.AopUtils.invokeJoinpointUsingReflection(AopUtils.java:317) ~[spring-aop-4.1.0.RELEASE.jar:4.1.0.RELEASE]
at org.springframework.aop.framework.ReflectiveMethodInvocation.invokeJoinpoint(ReflectiveMethodInvocation.java:190) ~[spring-aop-4.1.0.RELEASE.jar:4.1.0.RELEASE]
at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:157) ~[spring-aop-4.1.0.RELEASE.jar:4.1.0.RELEASE]
at org.springframework.transaction.interceptor.TransactionInterceptor$1.proceedWithInvocation(TransactionInterceptor.java:98) ~[spring-tx-4.1.0.RELEASE.jar:4.1.0.RELEASE]
at org.springframework.transaction.interceptor.TransactionAspectSupport.invokeWithinTransaction(TransactionAspectSupport.java:266) ~[spring-tx-4.1.0.RELEASE.jar:4.1.0.RELEASE] …

我在使用 Spring、Hibernate 和 JPA 的 Web 应用程序中遇到一些问题。问题是内存消耗非常高，随着时间的推移，内存消耗会增加，而且似乎永远不会减少。它们很可能源于 EntityManager 的错误使用。我已经四处寻找，但还没有找到确定的东西。

我们使用的 DAO 都扩展了以下 GenericDAO，其中注入了我们唯一的 EntityManager：

public abstract class GenericDAOImpl<E extends AbstractEntity<P>, P> implements
    GenericDAO<E, P> {

@PersistenceContext
@Autowired
private EntityManager entityManager;
    [...]

使用通用 DAO 是因为它具有通过 ID 等获取实体的方法，这在所有约 40 个 DAO 中实现起来会很痛苦。

EntityManager 通过以下方式配置为 Spring bean：

<bean class="org.springframework.orm.jpa.JpaTransactionManager"
    id="transactionManager">
    <property name="entityManagerFactory" ref="entityManagerFactory" />
</bean>
<tx:annotation-driven mode="aspectj"
    transaction-manager="transactionManager" />
<bean
    class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean"
    id="entityManagerFactory">
    <property name="persistenceUnitName" value="persistenceUnit" />
    <property name="dataSource" ref="dataSource" />
</bean>
<bean id="entityManager" factory-bean="entityManagerFactory"
    factory-method="createEntityManager" scope="singleton" />

我认为最大的问题是使用这个共享的 EntityManager 来处理所有事情。在服务类中，我们对需要事务的方法使用@Transactional 注释。这会根据我读取的内容自动刷新 EntityManager，但与清除不同，所以我猜对象仍在内存中。

我们注意到每天都会在数据库中自动导入数据后内存会增加（大约 …

想象一下,您有一个启动数据库事务的过滤器,处理请求,然后尝试提交事务.

doFilter(...) {
    ...
    transaction.begin();
    filterChain.doFilter(request, response);
    transaction.commit();
}

使用Jersey,有一些问题:

1. 使用过滤器,Jersey Servlet容器在执行返回过滤器之前提交/刷新响应.因此,如果提交失败,则无法将返回代码修改为失败.此外,JAX-RS ExceptionMapper不会捕获异常.

2. 使用ContainerRequestFilter/ContainerResponseFilter.

   public ContainerRequest过滤器(ContainerRequest请求){...}
   公共ContainerResponse过滤器(ContainerRequest请求,ContainerResponse响应){...}

这允许异常冒泡到ExceptionMapper,但是通过2个单独的方法/接口拆分逻辑.问题是,如果存在未映射到响应的异常,则永远不会调用ContainerResponseFilter,因此无法清理.

在JAX-RS环境中处理此问题的首选方法是什么？有没有办法配置响应的刷新,还是有一个我忽略的类或接口？

注意:请参阅我自己对此问题的回答,以获取我如何解决此问题的示例.

我在Spring MVC 4 + Hibernate 4项目中遇到以下异常:

org.hibernate.LazyInitializationException:懒得初始化一个角色集合:com.mysite.Company.acknowledgements,无法初始化代理 - 没有Session

在阅读了很多关于这个问题的其他问题后,我理解为什么会发生这种异常,但我不确定如何以一种好的方式解决它.我正在做以下事情:

1. 我的Spring MVC控制器调用服务中的方法
2. service方法调用DAO类中的方法
3. DAO类中的方法通过Hibernate获取实体对象并将其返回给调用服务
4. 该服务将获取的对象返回给控制器
5. 控制器将对象传递给视图(JSP)
6. 该视图尝试迭代一个懒惰加载的多对多关联(因此是一个代理对象)
7. 抛出异常是因为此时会话已关闭,并且代理无法加载关联数据

我之前使用过PHP和doctrine2,这种做事方式没有问题.我试图找出解决这个问题的最佳方法,因为到目前为止我找到的解决方案看起来并不那么好:

• 急切加载关联,可能会加载大量不必要的数据
• 调用Hibernate.initialize(myObject.getAssociation());- 这意味着我必须遍历关联来初始化它们(我猜),而且事实上我必须这样做,有点使得延迟加载不那么整洁
• 使用Spring过滤器在视图中打开会话,但我怀疑这是一件好事吗？

我试着@Transactional在我的服务中使用,但没有运气.这是有道理的,因为我试图访问我的服务方法返回后尚未加载的数据.理想情况下,我希望能够从我的视图中访问任何关联.我想在我的服务中初始化关联的缺点是我必须明确定义我需要的数据 - 但这取决于使用服务的上下文(控制器).我不确定我是否可以在我的控制器中执行此操作而不会丢失DBAL层提供的抽象.我希望这是有道理的.无论哪种方式,如果我不必总是明确定义我想要哪些数据可用于我的视图,那就太好了,但只是让视图做它的事情.如果那是不可能的,那么我只是在寻找最优雅的解决方案.

以下是我的代码.

视图

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>

<h1><c:out value="${company.name}" /> (ID: <c:out value="${company.id}" />)</h1>

<c:forEach var="acknowledgement" items="${company.acknowledgements}">
    <p><c:out value="${acknowledgement.name}" /></p>
</c:forEach>

调节器

@Controller
public class ProfileController {
    @Autowired
    private CompanyService companyService;

    @RequestMapping("/profile/view/{id}")
    public String view(Model model, @PathVariable int id) {
        Company …

在一个相对较大的 Spring Boot 项目中，我有一个具有以下（过于简化的）事件序列的方法：

Car car = carRepository.save(new Car());
Person person = personRepository.save(new Person(car)); // Car is a field of Person

Engine engine = engineRepository.save(new Engine());
person.getCar().setEngine(engine);

carRepository.save(person.getCar()); // without this the engine and car relation is not registered

Car、Person和Engine都是@Entity类（数据库对象）。对于这个例子，它们的实现可能如下：

// Car.java
@Entity
@Table(name = "car_tbl")
public class Car {
    @Id
    @GeneratedValue
    @Column(name = "car_id")
    private Long id;

    @OneToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "engine_id", unique = true)
    private Engine engine;
}

// Person.java …

我基于springboot创建了一个用户管理服务。

该用户将有一个列表附件，这样用户和依恋的关系是一对多。

我在这里忽略了插入逻辑，因为我的问题是关于延迟加载以及何时打开和关闭entitymanager。以下是实体，控制器，服务，Dao，存储库相关的代码。

实体

@Entity
@Table(name="User")
public class UserInfoEntity {

 private long id;
 private String mail;

 @OneToMany(fetch = FetchType.LAZY, mappedBy = "userInfoEntity", cascade = CascadeType.ALL)
 private List<UserAttachmentEntity> attachmentList = new ArrayList<>();

}


@Entity
@Table(name = "ATTACHMENT")
public class UserAttachmentEntity {
    private long id;

    private String name;

    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name="userRequestId")
    private UserInfoEntity userInfoEntity;

}

服务

@Service
public class UserServiceImpl implements UserService {

    @Autowired
    private UserDao userDao;


    @Override …