Hibernate take 2: lazy loading issue

[Bear Bibeault]

I used Hibernate for a small project a while back. While I liked the vastly decreased amount of code required over using raw JDBC, I had enough problems with it that I shelved it for the next few projects in the interest of getting them done quickly. I suspect that most of the problems I had were due to not really understanding the "what goes where and why" of Hibernate, and so now I'm giving it another go in a slightly more complex project (in which I have the luxury of taking the time to learn Hibernate principles properly).

I've got basic things running but am having an issue with lazy loading of a many-to-one association.

I have a class named Credentials that has a many-to-one association defined as follows:

  <class name="Credentials"
         table="trf_credentials"
         mutable="true">
 
    ...
 
    <many-to-one name="member"
                 class="Member"
                 column="member_id"
                 not-null="true"
                 cascade="all"/>
 
    ...
 
  </class>

The code in question performs a query for a Credentials instance (it's not being loaded by primary key, so I need the query) and then attempts to fetch the associated Member instance:

    Session session = HibernateUtil.getSessionFactory().openSession();
    Transaction tx = session.beginTransaction();
    Query query = session.createQuery("from Credentials as c where ... where clause here ...");
    query.setString( ... parameters set here ...);
    Credentials credentials = (Credentials)query.uniqueResult();
    if (credentials==null) return null;
    Member member = credentials.getMember();
    //log.info(" member: "+ member);
    tx.commit();
    session.close();
    log.info(" member: "+ member);
    return member;
}

When executed, I get the following:

23:04:51,588 ERROR LazyInitializationException:19 - could not initialize proxy - the owning Session was closed
org.hibernate.LazyInitializationException: could not initialize proxy - the owning Session was closed
at org.hibernate.proxy.AbstractLazyInitializer.initialize(AbstractLazyInitializer.java:56)
at org.hibernate.proxy.AbstractLazyInitializer.getImplementation(AbstractLazyInitializer.java:98)
at org.hibernate.proxy.CGLIBLazyInitializer.intercept(CGLIBLazyInitializer.java:158)
at com.therecipefile.core.model.membership.Member$$EnhancerByCGLIB$$e014be59.toString(<generated>  ;)  
at java.lang.String.valueOf(String.java:2615)
at java.lang.StringBuilder.append(StringBuilder.java:116)
at com.therecipefile.core.model.membership.Credentials.login(Credentials.java:145)
       ...    

Line 145 is the log.info() just before the return statement.

If I uncomment the log.info() just before the commit, all is well. So I gather that Member is not being realized before it gets accessed in some way and that has to happen while the persistence context is active.

It's obviously ridiculous to use a logging statement to trigger a semantic action in the code, so what's the correct way to ensure that Member is realized before closing the session without performing some hokey operation upon it just to trigger its realization?

I strongly suspect there's some Universal Hibernate Truth that I'm missing again.

Thanks for any insight.
[ April 26, 2008: Message edited by: Bear Bibeault ]

[Bear Bibeault]

P.S. The above is a simplification of the actual code that illustrates my question. The actual code is more robust about making sure that the transaction and sessions are properly closed.

P.P.S. Is the transaction really necessary when doing a query?

[Scott Selikoff]

This may or may not be related, but have you tried using container managed transactions? It's not often I call a method to explicitly begin/end a transaction in a J2EE application.

[Cameron Wallace McKenzie]

So, the Credentials object comes back, and it has an association with a Member. The Member is associated in a Lazy manner, so the Member is only loaded when the Credentials object needs it.

So, in this query, a Credentials object comes back initialized, but Hibernate does you the favor of only bringing back proxies for the many possible Member instances. The proxies are placeholders that will only ever be initialized if you explicitly ask for them through the getter of the Credentials object.

Now, the problem with lazy loading is that those getters on the Credentials object will only work if they are called within the confines of the transaction that loaded the the original Credential. If the transaction is committed without a member getter ever being called on the Credential, the transactional context is closed, and your Credential object has no way of using Hibernate to get the associated Member. The Hibernate Session wipes its hands clean of the associated credentials object once the transaction is comitted - the Credential becomes a detached instance once the transaction is committed, as opposed to a persistent instance that is managed by the Hibernate Session.

This method call though:

//log.info(" member: "+ member);

Does force Hibernate to replace the proxy with a real object. The transaction is live, so the data comes back. The POJO on the JVM is now real, and that's why this little gem of code makes everything work - the PROXY is replaced by a real object, DURING a transaction, and the member POJO lives on in the JVM after the transaction is committed.

I have a little tutorial on How Hibernate Works that discusses this.

How Hibernate Works

Of course, this doesn't solve the problem...

So, what you can do is mark the Credential to have a FetchType of EAGER, as opposed to LAZY. This way, all the Member objects will be loaded when the credential is loaded.

Another option is to extend the life of the transaction. Many 'simple' web applications use a single-transaction-per-cycle pattern (anti-pattern?) so the whole request-response cycle is done within a single transaction, which ends any LazyLoading problems. I think you can figure some drawbacks to that of course.

Another option might be to do a full load of the Credential object before doing the logging. Of course, that would probably cause more potential problems to log.

>>P.P.S. Is the transaction really necessary when doing a query?

I've been on a couple of blog sites (Googled them but couldn't find them), but I've read one of the writers of Hibernate (Bauer or King, can't remember) get very 'testy' when asked about this. Something about asking this question to their students after a week long class, and then throwing erasers at everyone that gets it wrong. Yes, a transaction is needed. Certainly, a Hibernate Session is needed to load data from the database, and an open, working, queryable session goes hand in hand with an open transaction.

And even more to the point, with one to many relationships, it may have be the same session that originally loaded the one side of the relationship. With a new session, the one side of the relationship will need to be reattached to the Hibernate Session, lest it be detached and trigger another LazyLoadingException.

By the way, JQuery in Action was very well done.

-Cameron McKenzie

[ April 27, 2008: Message edited by: Cameron Wallace McKenzie ]
[ April 27, 2008: Message edited by: Cameron Wallace McKenzie ]

[Bear Bibeault]

Thanks Cameron, that's pretty much what I figured was going on, and...

Originally posted by Cameron Wallace McKenzie:
[QB]So, what you can do is mark the Credential to have a FetchType of EAGER, as opposed to LAZY. This way, all the Member objects will be loaded when the credential is loaded.

that was what I was looking for!

By the way, JQuery in Action was very well done.

And thank you for that.

[Bear Bibeault]

Originally posted by Scott Selikoff:
This may or may not be related, but have you tried using container managed transactions?

Baby steps... just getting started. Besides, that sounds like something available only in a JEE container?

[Bear Bibeault]

but I've read one of the writers of Hibernate (Bauer or King, can't remember) get very 'testy' when asked about this.

Interesting. The reason is that in thumbing through Bauer's book, he seems to skip the transactions on queries and I didn't know if that was just a brevity thing or not.

[Skip Cole]

Great question and great thread!

I was using Hibernate as a simple tool to replace my hand written SQL statements, and then ran up against this dreaded LazyInitializationError. Now I at least know why.

Has Hibernate grown 'a feature too far'? Does it have to do all of this stuff in the background. I liked it when I thought it was a simpler tool. This new paradigm will take me a while to get used to.

[Philippe Desrosiers]

Sorry for the Thread-necromancy, but, amazingly, this is the only thread on the forum that appears when I search for "LazyInitializationError".

Yes, I'm getting the LazyInitializationError, while trying to write a Spring/Hibernate/Quartz application. The app runs as a SpringContextLoaderServlet. There is no "view" to speak of, since there's no UI. The context is loaded at startup, the jobs are scheduled, and away we go!

I'm using a Dao package in a separate Jar, where all Dao classes extend Spring's org.springframework.orm.hibernate3.support.HibernateDaoSupport.

Here is my context.xml (just the database bits, since the Quartz bits are working fine...):

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">

    <import resource="hibernate.xml"/>

    <!-- interceptor -->
    <bean id="hibernateInterceptor" class="org.springframework.orm.hibernate3.HibernateInterceptor">
        <property name="sessionFactory">
            <ref bean="sessionFactory"/>
        </property>
    </bean>

    <!-- Dao layer -->

    <bean id="accountDao" class="org.springframework.aop.framework.ProxyFactoryBean">
        <property name="proxyInterfaces">
            <value>com.testproject.aggregation.dao.AccountDao</value>
        </property>
        <property name="interceptorNames">
            <list>
                <value>hibernateInterceptor</value>
            </list>
        </property>
        <property name="target">
            <bean id="accountDaoTarget" class="com.testproject.aggregation.dao.hibernate.HibernateAccountDao">
                <property name="sessionFactory">
                    <ref bean="sessionFactory"/>
                </property>
                <property name="hibernateTemplate">
                    <ref bean="hibernateTemplate"/>
                </property>
            </bean>
        </property>
    </bean>

    <bean id="audioDao" class="org.springframework.aop.framework.ProxyFactoryBean">
        <property name="proxyInterfaces">
            <value>com.testproject.aggregation.dao.AudioDao</value>
        </property>
        <property name="interceptorNames">
            <list>
                <value>hibernateInterceptor</value>
            </list>
        </property>
        <property name="target">
            <bean id="audioDaoTarget" class="com.testproject.aggregation.dao.hibernate.HibernateAudioDao">
                <property name="sessionFactory">
                    <ref bean="sessionFactory"/>
                </property>
                <property name="hibernateTemplate">
                    <ref bean="hibernateTemplate"/>
                </property>
            </bean>
        </property>
    </bean>


    <bean id="languageDao" class="org.springframework.aop.framework.ProxyFactoryBean">
        <property name="proxyInterfaces">
            <value>com.testproject.aggregation.dao.LanguageDao</value>
        </property>
        <property name="interceptorNames">
            <list>
                <value>hibernateInterceptor</value>
            </list>
        </property>
        <property name="target">
            <bean id="languageDaoTarget" class="com.testproject.aggregation.dao.hibernate.HibernateLanguageDao">
                <property name="sessionFactory">
                    <ref bean="sessionFactory"/>
                </property>
                <property name="hibernateTemplate">
                    <ref bean="hibernateTemplate"/>
                </property>
            </bean>
        </property>
    </bean>

    <bean id="productDao" class="org.springframework.aop.framework.ProxyFactoryBean">
        <property name="proxyInterfaces">
            <value>com.testproject.aggregation.dao.ProductDao</value>
        </property>
        <property name="interceptorNames">
            <list>
                <value>hibernateInterceptor</value>
            </list>
        </property>
        <property name="target">
            <bean class="com.testproject.aggregation.dao.hibernate.HibernateProductDao">
                <property name="sessionFactory">
                    <ref bean="sessionFactory"/>
                </property>
                <property name="hibernateTemplate">
                    <ref bean="hibernateTemplate"/>
                </property>
            </bean>
        </property>
    </bean>

    <bean id="productStatusDao" class="org.springframework.aop.framework.ProxyFactoryBean">
        <property name="proxyInterfaces">
            <value>com.testproject.aggregation.dao.ProductStatusDao</value>
        </property>
        <property name="interceptorNames">
            <list>
                <value>hibernateInterceptor</value>
            </list>
        </property>
        <property name="target">
            <bean class="com.testproject.aggregation.dao.hibernate.HibernateProductStatusDao">
                <property name="sessionFactory">
                    <ref bean="sessionFactory"/>
                </property>
                <property name="hibernateTemplate">
                    <ref bean="hibernateTemplate"/>
                </property>
            </bean>
        </property>
    </bean>

    <bean id="productTextDao" class="org.springframework.aop.framework.ProxyFactoryBean">
        <property name="proxyInterfaces">
            <value>com.testproject.aggregation.dao.ProductTextDao</value>
        </property>
        <property name="interceptorNames">
            <list>
                <value>hibernateInterceptor</value>
            </list>
        </property>
        <property name="target">
            <bean class="com.testproject.aggregation.dao.hibernate.HibernateProductTextDao">
                <property name="sessionFactory">
                    <ref bean="sessionFactory"/>
                </property>
                <property name="hibernateTemplate">
                    <ref bean="hibernateTemplate"/>
                </property>
            </bean>
        </property>
    </bean>

    <bean id="productTypeDao" class="org.springframework.aop.framework.ProxyFactoryBean">
        <property name="proxyInterfaces">
            <value>com.testproject.aggregation.dao.ProductTypeDao</value>
        </property>
        <property name="interceptorNames">
            <list>
                <value>hibernateInterceptor</value>
            </list>
        </property>
        <property name="target">
            <bean class="com.testproject.aggregation.dao.hibernate.HibernateProductTypeDao">
                <property name="sessionFactory">
                    <ref bean="sessionFactory"/>
                </property>
                <property name="hibernateTemplate">
                    <ref bean="hibernateTemplate"/>
                </property>
            </bean>
        </property>
    </bean>

    <bean id="roleDao" class="org.springframework.aop.framework.ProxyFactoryBean">
        <property name="proxyInterfaces">
            <value>com.testproject.aggregation.dao.RoleDao</value>
        </property>
        <property name="interceptorNames">
            <list>
                <value>hibernateInterceptor</value>
            </list>
        </property>
        <property name="target">
            <bean class="com.testproject.aggregation.dao.hibernate.HibernateRoleDao">
                <property name="sessionFactory">
                    <ref bean="sessionFactory"/>
                </property>
                <property name="hibernateTemplate">
                    <ref bean="hibernateTemplate"/>
                </property>
            </bean>
        </property>
    </bean>

    <bean id="submissionDao" class="org.springframework.aop.framework.ProxyFactoryBean">
        <property name="proxyInterfaces">
            <value>com.testproject.aggregation.dao.SubmissionDao</value>
        </property>
        <property name="interceptorNames">
            <list>
                <value>hibernateInterceptor</value>
            </list>
        </property>
        <property name="target">
            <bean class="com.testproject.aggregation.dao.hibernate.HibernateSubmissionDao">
                <property name="sessionFactory">
                    <ref bean="sessionFactory"/>
                </property>
                <property name="hibernateTemplate">
                    <ref bean="hibernateTemplate"/>
                </property>
            </bean>
        </property>
    </bean>

    <bean id="submissionStatusDao" class="org.springframework.aop.framework.ProxyFactoryBean">
        <property name="proxyInterfaces">
            <value>com.testproject.aggregation.dao.SubmissionStatusDao</value>
        </property>
        <property name="interceptorNames">
            <list>
                <value>hibernateInterceptor</value>
            </list>
        </property>
        <property name="target">
            <bean class="com.testproject.aggregation.dao.hibernate.HibernateSubmissionStatusDao">
                <property name="sessionFactory">
                    <ref bean="sessionFactory"/>
                </property>
                <property name="hibernateTemplate">
                    <ref bean="hibernateTemplate"/>
                </property>
            </bean>
        </property>
    </bean>

    <bean id="userDao" class="org.springframework.aop.framework.ProxyFactoryBean">
        <property name="proxyInterfaces">
            <value>com.testproject.aggregation.dao.UserDao</value>
        </property>
        <property name="interceptorNames">
            <list>
                <value>hibernateInterceptor</value>
            </list>
        </property>
        <property name="target">
            <bean class="com.testproject.aggregation.dao.hibernate.HibernateUserDao">
                <property name="sessionFactory">
                    <ref bean="sessionFactory"/>
                </property>
                <property name="hibernateTemplate">
                    <ref bean="hibernateTemplate"/>
                </property>
            </bean>
        </property>
    </bean>

    <bean id="wallpaperDao" class="org.springframework.aop.framework.ProxyFactoryBean">
        <property name="proxyInterfaces">
            <value>com.testproject.aggregation.dao.WallpaperDao</value>
        </property>
        <property name="interceptorNames">
            <list>
                <value>hibernateInterceptor</value>
            </list>
        </property>
        <property name="target">
            <bean class="com.testproject.aggregation.dao.hibernate.HibernateWallpaperDao">
                <property name="sessionFactory">
                    <ref bean="sessionFactory"/>
                </property>
                <property name="hibernateTemplate">
                    <ref bean="hibernateTemplate"/>
                </property>
            </bean>
        </property>
    </bean>
    <bean id="dataSource" class="org.springframework.jndi.JndiObjectFactoryBean">
        <property name="jndiName" value="java:comp/env/subDB"/>
    </bean>

    <bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
        <property name="mappingResources" ref="mappingResources"/>
        <property name="hibernateProperties" ref="hibernateProperties"/>
        <property name="dataSource" ref="dataSource"/>
    </bean>

    <!--  Hibernate Properties -->
    <bean id="hibernateProperties" class="org.springframework.beans.factory.config.PropertiesFactoryBean">
        <property name="properties">
            <props>
                <prop key="hibernate.dialect">org.hibernate.dialect.MySQL5InnoDBDialect</prop>
                <prop key="hibernate.show_sql">true</prop>
                <prop key="hibernate.max_fetch_depth">4</prop>
                <!--<prop key="hibernate.flushMode">AUTO</prop>-->
                <prop key="hibernate.hibernate.cache.use_query_cache">true</prop>
                <prop key="hibernate.jdbc.batch_size">50</prop>
                <!--<prop key="hibernate.connection.release_mode">auto</prop>-->
                <!--<prop key="transaction.factory_class">org.hibernate.transaction.JDBCTransactionFactory</prop>-->

                <!-- Connection Pool -->
                <prop key="hibernate.connection.pool_size">10</prop>
                <prop key="hibernate.c3p0.min_size">1</prop>
                <prop key="hibernate.c3p0.max_size">20</prop>
                <prop key="hibernate.c3p0.timeout">1800</prop>
                <prop key="hibernate.c3p0.max_statements">100</prop>

                <!-- Use EHCache as secondary cache-->
                <prop key="hibernate.cache.use_query_cache">true</prop>
                <prop key="hibernate.cache.provider_class">org.hibernate.cache.EhCacheProvider</prop>
                <prop key="hibernate.cache.provider_configuration_file_resource_path">com/testproject/aggregation/dao/hibernate/ehcache.xml</prop>
            </props>
        </property>
    </bean>


    <bean id="hibernateTemplate" class="org.springframework.orm.hibernate3.HibernateTemplate">
        <constructor-arg>
            <ref bean="sessionFactory"/>
        </constructor-arg>
    </bean>

    <bean id="hibernateTransactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
        <constructor-arg>
            <ref bean="sessionFactory"/>
        </constructor-arg>
    </bean>

    <!--  hibernate mapping files (in dao JAR) -->
    <bean id="mappingResources" class="org.springframework.beans.factory.config.ListFactoryBean">
        <property name="sourceList">
            <list>
                <value>com/testproject/aggregation/entities/Account.hbm.xml</value>
                <value>com/testproject/aggregation/entities/Audio.hbm.xml</value>
                <value>com/testproject/aggregation/entities/Language.hbm.xml</value>
                <value>com/testproject/aggregation/entities/Product.hbm.xml</value>
                <value>com/testproject/aggregation/entities/ProductFile.hbm.xml</value>
                <value>com/testproject/aggregation/entities/ProductStatus.hbm.xml</value>
                <value>com/testproject/aggregation/entities/ProductText.hbm.xml</value>
                <value>com/testproject/aggregation/entities/ProductType.hbm.xml</value>
                <value>com/testproject/aggregation/entities/ProductFileType.hbm.xml</value>
                <value>com/testproject/aggregation/entities/Role.hbm.xml</value>
                <value>com/testproject/aggregation/entities/Submission.hbm.xml</value>
                <value>com/testproject/aggregation/entities/SubmissionStatus.hbm.xml</value>
                <value>com/testproject/aggregation/entities/User.hbm.xml</value>
                <value>com/testproject/aggregation/entities/Wallpaper.hbm.xml</value>
            </list>
        </property>
    </bean>

</beans>

If I understand correctly, the hibernateInterceptor should intercept any method calls on any of those Dao instances, and if necessary open a session. After which, the HibernateDaoSupport will use whatever local Session is already open to execute the various Dao methods (correct me if I'm wrong).

Here's the java code that's causing the problem:

		//AppContext is a convenience class that points to the Spring context beans.
		User phil = AppContext.getUserDao().get("phil"); //gets an instance of com.testproject.aggregation.entities.User
		phil.setFullName("Philippe Desrosiers (mod: " + System.currentTimeMillis() + ")");  //sets the name of the user.
		phil.getAccount().setName(phil.getAccount().getName() + " (mod:" + System.currentTimeMillis() + ")");  //BARFS WITH LAZYINITIALIZATIONERROR
		AppContext.getUserDao().save(phil);  //never gets here.

Here's what I get in the (copious) logs:

2009-05-15 16:16:55,001 [DEBUG] core.JobRunShell  - Calling execute on job DEFAULT.Test.Hibernate
2009-05-15 16:16:55,001 [INFO ] Test.Hibernate    - Starting Job 'Test.Hibernate'
2009-05-15 16:16:55,001 [DEBUG] support.DefaultListableBeanFactory - Returning cached instance of singleton bean 'sessionFactory'
2009-05-15 16:16:55,001 [DEBUG] hibernate3.SessionFactoryUtils - Opening Hibernate Session
2009-05-15 16:16:55,001 [DEBUG] impl.SessionImpl  - opened session at timestamp: 5088946647044096
2009-05-15 16:16:55,001 [DEBUG] transaction.JDBCTransaction - begin
2009-05-15 16:16:55,001 [DEBUG] jdbc.ConnectionManager - opening JDBC connection
2009-05-15 16:16:55,001 [DEBUG] transaction.JDBCTransaction - current autocommit status: true
2009-05-15 16:16:55,002 [DEBUG] transaction.JDBCTransaction - disabling autocommit
2009-05-15 16:16:55,002 [DEBUG] support.DefaultListableBeanFactory - Returning cached instance of singleton bean 'userDao'
2009-05-15 16:16:55,003 [DEBUG] hibernate3.SessionFactoryUtils - Opening Hibernate Session
2009-05-15 16:16:55,003 [DEBUG] impl.SessionImpl  - opened session at timestamp: 5088946647052288
2009-05-15 16:16:55,003 [DEBUG] loader.Loader     - loading entity: [com.testproject.aggregation.entities.User#phil]
2009-05-15 16:16:55,003 [DEBUG] jdbc.AbstractBatcher - about to open PreparedStatement (open PreparedStatements: 0, globally: 0)
2009-05-15 16:16:55,003 [DEBUG] jdbc.ConnectionManager - opening JDBC connection
2009-05-15 16:16:55,047 [DEBUG] hibernate.SQL     - select user0_.login as login14_0_, user0_.accountId as accountId14_0_, user0_.fullName as fullName14_0_, user0_.password as password14_0_, user0_.enabled as enabled14_0_, user0_.email as email14_0_, user0_.newPassword as newPassw7_14_0_, user0_.pwToken as pwToken14_0_ from submissions.User user0_ where user0_.login=?
Hibernate: select user0_.login as login14_0_, user0_.accountId as accountId14_0_, user0_.fullName as fullName14_0_, user0_.password as password14_0_, user0_.enabled as enabled14_0_, user0_.email as email14_0_, user0_.newPassword as newPassw7_14_0_, user0_.pwToken as pwToken14_0_ from submissions.User user0_ where user0_.login=?
2009-05-15 16:16:55,047 [DEBUG] jdbc.AbstractBatcher - about to open ResultSet (open ResultSets: 0, globally: 0)
2009-05-15 16:16:55,047 [DEBUG] loader.Loader     - result row: EntityKey[com.testproject.aggregation.entities.User#phil]
2009-05-15 16:16:55,048 [DEBUG] jdbc.AbstractBatcher - about to close ResultSet (open ResultSets: 1, globally: 1)
2009-05-15 16:16:55,048 [DEBUG] jdbc.AbstractBatcher - about to close PreparedStatement (open PreparedStatements: 1, globally: 1)
2009-05-15 16:16:55,048 [DEBUG] engine.TwoPhaseLoad - resolving associations for [com.testproject.aggregation.entities.User#phil]
2009-05-15 16:16:55,048 [DEBUG] engine.TwoPhaseLoad - done materializing entity [com.testproject.aggregation.entities.User#phil]
2009-05-15 16:16:55,048 [DEBUG] engine.StatefulPersistenceContext - initializing non-lazy collections
2009-05-15 16:16:55,048 [DEBUG] loader.Loader     - done entity load
2009-05-15 16:16:55,048 [DEBUG] jdbc.ConnectionManager - transaction completed on session with on_close connection release mode; be sure to close the session to release JDBC resources!
2009-05-15 16:16:55,048 [DEBUG] hibernate3.HibernateTemplate - Eagerly flushing Hibernate session
2009-05-15 16:16:55,048 [DEBUG] def.AbstractFlushingEventListener - processing flush-time cascades
2009-05-15 16:16:55,048 [DEBUG] def.AbstractFlushingEventListener - dirty checking collections
2009-05-15 16:16:55,048 [DEBUG] engine.Collections - Collection found: [com.testproject.aggregation.entities.User.submissions#phil], was: [com.testproject.aggregation.entities.User.submissions#phil] (uninitialized)
2009-05-15 16:16:55,048 [DEBUG] engine.Collections - Collection found: [com.testproject.aggregation.entities.User.managedAccounts#phil], was: [com.testproject.aggregation.entities.User.managedAccounts#phil] (uninitialized)
2009-05-15 16:16:55,048 [DEBUG] engine.Collections - Collection found: [com.testproject.aggregation.entities.User.roles#phil], was: [com.testproject.aggregation.entities.User.roles#phil] (uninitialized)
2009-05-15 16:16:55,048 [DEBUG] def.AbstractFlushingEventListener - Flushed: 0 insertions, 0 updates, 0 deletions to 1 objects
2009-05-15 16:16:55,048 [DEBUG] def.AbstractFlushingEventListener - Flushed: 0 (re)creations, 0 updates, 0 removals to 3 collections
2009-05-15 16:16:55,048 [DEBUG] pretty.Printer    - listing entities:
2009-05-15 16:16:55,048 [DEBUG] pretty.Printer    - com.testproject.aggregation.entities.User{enabled=true, email=[e-mail], newPassword=null, roles=<uninitialized>, pwToken=null, account=com.testproject.aggregation.entities.Account#1, submissions=<uninitialized>, login=phil, managedAccounts=<uninitialized>, fullName=Philippe Desrosiers (mod: 1242417025006), password=9044124}
2009-05-15 16:16:55,049 [DEBUG] hibernate3.SessionFactoryUtils - Closing Hibernate Session
2009-05-15 16:16:55,049 [DEBUG] jdbc.ConnectionManager - releasing JDBC connection [ (open PreparedStatements: 0, globally: 0) (open ResultSets: 0, globally: 0)]
2009-05-15 16:16:55,049 [DEBUG] jdbc.ConnectionManager - transaction completed on session with on_close connection release mode; be sure to close the session to release JDBC resources!
2009-05-15 16:16:55,049 [ERROR] hibernate.LazyInitializationException - could not initialize proxy - the owning Session was closed
org.hibernate.LazyInitializationException: could not initialize proxy - the owning Session was closed
	at org.hibernate.proxy.AbstractLazyInitializer.initialize(AbstractLazyInitializer.java:60)
	at org.hibernate.proxy.AbstractLazyInitializer.getImplementation(AbstractLazyInitializer.java:111)
	at org.hibernate.proxy.pojo.cglib.CGLIBLazyInitializer.invoke(CGLIBLazyInitializer.java:172)
	at com.testproject.aggregation.entities.Account$$EnhancerByCGLIB$$3c3bb8a0.getName(<generated>)
	at com.testproject.aggregation.jobs.HibernateTestJob.jobAction(HibernateTestJob.java:40)
	at com.testproject.scheduling.ChainableJobBean.executeInternal(ChainableJobBean.java:76)
	at org.springframework.scheduling.quartz.QuartzJobBean.execute(QuartzJobBean.java:86)
	at org.quartz.core.JobRunShell.run(JobRunShell.java:202)
	at org.quartz.simpl.SimpleThreadPool$WorkerThread.run(SimpleThreadPool.java:525)
2009-05-15 16:16:55,074 [ERROR] core.JobRunShell  - Job DEFAULT.Test.Hibernate threw an unhandled Exception: 
org.hibernate.LazyInitializationException: could not initialize proxy - the owning Session was closed
	at org.hibernate.proxy.AbstractLazyInitializer.initialize(AbstractLazyInitializer.java:60)
	at org.hibernate.proxy.AbstractLazyInitializer.getImplementation(AbstractLazyInitializer.java:111)
	at org.hibernate.proxy.pojo.cglib.CGLIBLazyInitializer.invoke(CGLIBLazyInitializer.java:172)
	at com.testproject.aggregation.entities.Account$$EnhancerByCGLIB$$3c3bb8a0.getName(<generated>)
	at com.testproject.aggregation.jobs.HibernateTestJob.jobAction(HibernateTestJob.java:40)
	at com.testproject.scheduling.ChainableJobBean.executeInternal(ChainableJobBean.java:76)
	at org.springframework.scheduling.quartz.QuartzJobBean.execute(QuartzJobBean.java:86)
	at org.quartz.core.JobRunShell.run(JobRunShell.java:202)
	at org.quartz.simpl.SimpleThreadPool$WorkerThread.run(SimpleThreadPool.java:525)
2009-05-15 16:16:55,102 [ERROR] core.ErrorLogger  - Job (DEFAULT.Test.Hibernate threw an exception.
org.quartz.SchedulerException: Job threw an unhandled exception. [See nested exception: org.hibernate.LazyInitializationException: could not initialize proxy - the owning Session was closed]
	at org.quartz.core.JobRunShell.run(JobRunShell.java:213)
	at org.quartz.simpl.SimpleThreadPool$WorkerThread.run(SimpleThreadPool.java:525)
Caused by: org.hibernate.LazyInitializationException: could not initialize proxy - the owning Session was closed
	at org.hibernate.proxy.AbstractLazyInitializer.initialize(AbstractLazyInitializer.java:60)
	at org.hibernate.proxy.AbstractLazyInitializer.getImplementation(AbstractLazyInitializer.java:111)
	at org.hibernate.proxy.pojo.cglib.CGLIBLazyInitializer.invoke(CGLIBLazyInitializer.java:172)
	at com.testproject.aggregation.entities.Account$$EnhancerByCGLIB$$3c3bb8a0.getName(<generated>)
	at com.testproject.aggregation.jobs.HibernateTestJob.jobAction(HibernateTestJob.java:40)
	at com.testproject.scheduling.ChainableJobBean.executeInternal(ChainableJobBean.java:76)
	at org.springframework.scheduling.quartz.QuartzJobBean.execute(QuartzJobBean.java:86)
	at org.quartz.core.JobRunShell.run(JobRunShell.java:202)
	... 1 more

I have no @Transactional annotations or anything, so I'm not sure why HibernateTemplate would always flush the session so eagerly (or even whether that matters or not)?

Please GOD, someone help! I've struggled with this LazyInitializationError for months now, with no one able to give me a solution. I just want to be able to use a Spring HibernateDaoSupport inside a non-MVC, non-UI web app with no view. Is that so hard?

If it helps at all, I have a separate admin applciation that uses the same Dao library, with an OSIV interceptor, without any problem at all. So I know it must be technically possible, somewhere in the guts of Spring / Hibernate.

Help!

[Philippe Desrosiers]

UPDATE: So was reading this and it seems that the HibernateInterceptor is set up to Open a session (if necessary) every time one of the "target" class methods is called, then immediately close it once the method returns.

Leave aside for the moment that I can't begin to imagine a scenario where this would be the slightest bit useful (Think of a call to dao.get() method, followed by setting some properties, followed by a dao.save(). This would throw an unbound session exception of some sort). My point is, that I had misunderstood the purpose of the interceptor.

So I guess what I need, is for this interceptor to come into play when calling the executeInternal() method of my quartz Job instead!

...Of course, there's no way to configure this in Spring, since the Job is created ad hoc at runtime by the scheduler, rather than by Spring at Context load-time. So I can't reference it in my interceptor configuration.

If anyone knows a way to do this, let me know. Until then, I guess I'll keep searching...