Hibernate / Spring：懒得初始化 - 没有关闭会话或会话

7 回答

• 0

  我来到这里寻找有关类似问题的提示 . 我尝试了Thierry提到的解决方案，但它没有用 . 之后，我尝试了这些线，它工作：

  SessionFactory sessionFactory = (SessionFactory) context.getBean("sessionFactory");
  Session session = SessionFactoryUtils.getSession(sessionFactory, true);
  TransactionSynchronizationManager.bindResource(sessionFactory, new SessionHolder(session));
  

  事实上，我所做的是一个必须利用Spring存在经理/服务的批处理 . 在加载上下文并进行一些调用之后，我创建了一个着名的问题“未能懒惰地初始化集合” . 那3行为我解决了 .

  回复于 2024-04-25T21:10:03+08:00
• 2

  我认为你不应该使用hibernate会话事务方法，但让spring做到这一点 .

  将此添加到您的spring conf：

  <bean id="txManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
      <property name="sessionFactory" ref="mySessionFactory" />
  </bean>
  
  <bean id="transactionTemplate" class="org.springframework.transaction.support.TransactionTemplate">
      <property name="transactionManager" ref="txManager"/>
  </bean>
  

  然后我会修改你的测试方法以使用spring transaction模板：

  public static void main(String[] args) {
      // init here (getting dao and transaction template)
  
      transactionTemplate.execute(new TransactionCallback() {
          @Override
          public Object doInTransaction(TransactionStatus status) {
            // do your hibernate stuff in here : call save, list method, etc
          }
      }
  }
  

  作为旁注，默认情况下@OneToMany关联是惰性的，因此您不需要将其注释为惰性 . （@ * ToMany默认为LAZY，默认情况下@ * ToOne为EAGER）

  编辑：现在从hibernate的角度来看现在发生了什么：

  • 开放会话（有交易开始）

  • 保存用户并将其保留在会话中（将会话缓存视为实体哈希映射，其中密钥是实体ID）

  • 保存一个事件并将其保留在会话中

  • 保存另一个事件并将其保留在会话中

  • ...与所有保存操作相同...

  • 然后加载所有用户（“来自用户”查询）

  • 那时hibernate看到它已经在会话中已经有了对象，所以丢弃它从请求中得到的对象并从会话中返回一个 .

  • 会话中的用户没有初始化其事件集合，因此您将获得null .

  • ......

  以下是一些增强代码的要点：

  在模型中

  • ，当不需要集合排序时，使用Set，而不是List的集合（私有Set事件，而不是私有List事件）
    在模型中

  • ，键入你的集合，否则hibernate将不会获取哪个实体（私有Set <Event>事件）

  • 当您设置双向关系的一侧，并且您希望在同一事务中使用关系的mappedBy端时，请设置两侧 . 在下一个tx之前，Hibernate不会为你做这件事（当会话是来自db状态的全新视图时） .

  因此，为了解决上述问题，要么在一个事务中进行保存，要么在另一个事务中进行加载：

  public static void main(String[] args) {
      // init here (getting dao and transaction template)
      transactionTemplate.execute(new TransactionCallback() {
          @Override
          public Object doInTransaction(TransactionStatus status) {
            // save here
          }
      }
  
      transactionTemplate.execute(new TransactionCallback() {
          @Override
          public Object doInTransaction(TransactionStatus status) {
            // list here
          }
      }
  }
  

  或两者兼而有之双方：

  ...
  event1.setUser(user);
  ...
  event2.setUser(user);
  ...
  user.setEvents(Arrays.asList(event1,event2));
  ...
  

  （另外不要忘记解决上面的代码增强点，Set not List，集合打字）

  回复于 2024-04-25T21:10:03+08:00
• 3

  对于Web应用程序，还可以在web.xml中声明一个特殊的Filter，它将执行session-per-request：

  <filter>
      <filter-name>openSessionInViewFilter</filter-name>
      <filter-class>org.springframework.orm.hibernate3.support.OpenSessionInViewFilter</filter-class>
  </filter>
  
  <filter-mapping>
      <filter-name>openSessionInViewFilter</filter-name>
      <url-pattern>/*</url-pattern>
  </filter-mapping>
  

  之后，您可以在请求期间随时延迟加载数据 .

  回复于 2024-04-25T21:10:03+08:00
• 9

  问题是你的dao正在使用一个hibernate会话，但是user.getName的延迟加载（我假设它就是它抛出的地方）正在该会话之外发生 - 要么根本不在会话中，要么在另一个会话中 . 通常我们在进行DAO调用之前打开一个hibernate会话，并且在完成所有延迟加载之前不要关闭它 . Web请求通常包含在大型会话中，因此不会发生这些问题 .

  通常我们在SessionWrapper中包含了dao和lazy调用 . 类似于以下内容：

  public class SessionWrapper {
      private SessionFactory sessionFactory;
      public void setSessionFactory(SessionFactory sessionFactory) {
          this.hibernateTemplate = new HibernateTemplate(sessionFactory);
      }
      public <T> T runLogic(Callable<T> logic) throws Exception {
          Session session = null;
          // if the session factory is already registered, don't do it again
          if (TransactionSynchronizationManager.getResource(sessionFactory) == null) {
              session = SessionFactoryUtils.getSession(sessionFactory, true);
              TransactionSynchronizationManager.bindResource(sessionFactory, new SessionHolder(session));
          }
  
          try {
              return logic.call();
          } finally {
              // if we didn't create the session don't unregister/release it
              if (session != null) {
                  TransactionSynchronizationManager.unbindResource(sessionFactory);
                  SessionFactoryUtils.releaseSession(session, sessionFactory);
              }
          }
      }
  }
  

  显然，SessionFactory与你的dao注入了相同的SessionFactory .

  ---

  在您的情况下，您应该将整个listUserWithEvent主体包装在此逻辑中 . 就像是：

  public List listUserWithEvent() {
      return sessionWrapper.runLogic(new Callable<List>() {
          public List call() {
              List users = hibernateTemplate.find("from User");
              for (User user : users) {
                  System.out.println("LIST : " + user.getName() + ":");
                  user.getEvents().size();
              }
          }
      });
  }
  

  您需要将SessionWrapper实例注入到您的daos中 .

  回复于 2024-04-25T21:10:03+08:00
• 7

  有趣！

  我在@Controller的@RequestMapping处理程序方法中遇到了同样的问题 . 简单的解决方案是在处理程序方法中添加@Transactional注释，以便在方法体执行的整个持续时间内保持会话打开

  回复于 2024-04-25T21:10:03+08:00
• 1

  Easiest solution to implement:

  在会话范围内[在使用@Transactional注释的API内]，执行以下操作：

  如果A有一个懒惰加载的List <B>，只需调用一个API，确保加载List

  What's that API ?

  尺寸（）; List类的API .

  So all that's needed is:

  Logger.log（a.getBList.size（））;

  记录大小的这个简单调用确保它在计算列表大小之前获得整个列表 . 现在你不会得到例外！

  回复于 2024-04-25T21:10:03+08:00
• 26

  在JBoss中对我们有用的是从＃1262613_获取的解决方案＃2 .

  web.xml中：

  <filter>
        <filter-name>ConnectionFilter</filter-name>
        <filter-class>web.ConnectionFilter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>ConnectionFilter</filter-name>
        <url-pattern>/faces/*</url-pattern>
    </filter-mapping>
  

  ConnectionFilter：

  import java.io.IOException;
  import javax.annotation.Resource;
  import javax.servlet.*;
  import javax.transaction.UserTransaction;
  
  public class ConnectionFilter implements Filter {
      @Override
      public void destroy() { }
  
      @Resource
      private UserTransaction utx;
  
      @Override
      public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
          try {
              utx.begin();
              chain.doFilter(request, response);
              utx.commit();
          } catch (Exception e) { }
      }
  
      @Override
      public void init(FilterConfig arg0) throws ServletException { }
  }
  

  也许它也适用于Spring .

  回复于 2024-04-25T21:10:03+08:00