Getting & ldquo; can not initialize proxy - no Session & rdquo; despite the fact that I use an @Transactional annotation

I'm using Spring 3.1.1.RELEASE and Hibernate 4.1.0.Final. I'm getting a "could not initialize proxy - no Session" exception, despite the fact I'm wrapping the relevant method call in a @Transactional annotation. Here's my method …

@Service("teacherImportService")
public class TeacherImportServiceImpl extends AbstractmyprojectService
{
    …
    @Transactional
    @Override
    public void saveUserObject(final JsonObject jsonData)
    {
        …
        final myprojectOrganization myprojectOrg = myprojectOrgDao.findBymyprojectOrgId(myprojectSchoolId);
        final Organization school = myprojectOrg != null ? myprojectOrg.getOrg() : null;
            …
        final Address address = new Address();
        address.setState(school.getState());    // error occurs here

What else do I have to do to guarantee a transaction takes place? I have included the "<tx:annotation-driven />" in my application context, which I include below

<context:component-scan base-package="org.mainco.subco" />
...
<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
    <property name="driverClassName" value="${test.mysql.dataSource.driverClassName}" />
    <property name="url" value="${test.mysql.dataSource.url}" />
    <property name="username" value="${test.mysql.db.user}" />
    <property name="password" value="${test.mysql.db.password}" />
</bean>

<bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
    <property name="packagesToScan" value="org.mainco.subco" />
    <property name="jpaVendorAdapter">
        <bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter"/>
    </property>
    <property name="dataSource" ref="dataSource"/>
    <property name="jpaPropertyMap" ref="jpaPropertyMap" />
</bean>

<util:map id="jpaPropertyMap">
    <entry key="hibernate.show_sql" value="true" />
    <entry key="hibernate.dialect" value="org.hibernate.dialect.MySQLDialect" />
    <entry key="hibernate.cache.region.factory_class" value="org.hibernate.cache.ehcache.EhCacheRegionFactory"/>
    <entry key="hibernate.cache.provider_class" value="org.hibernate.cache.EhCacheProvider"/>
    <entry key="hibernate.cache.use_second_level_cache" value="true" />
    <entry key="hibernate.cache.use_query_cache" value="false" />
    <entry key="hibernate.generate_statistics" value="true" />
</util:map>

<bean id="sharedEntityManager" class="org.springframework.orm.jpa.support.SharedEntityManagerBean">
   <property name="entityManagerFactory" ref="entityManagerFactory"/>
</bean>

<bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
    <property name="entityManagerFactory" ref="entityManagerFactory"/>
</bean>

<tx:annotation-driven />

<jdbc:initialize-database data-source="dataSource">
    <jdbc:script location="classpath:truncate_tables.sql" />
    <jdbc:script location="classpath:db-test-data.sql" />
</jdbc:initialize-database>

Here is full stack trace of the exception ...

org.hibernate.LazyInitializationException: could not initialize proxy - no Session
    at org.hibernate.proxy.AbstractLazyInitializer.initialize(AbstractLazyInitializer.java:149)
    at org.hibernate.proxy.AbstractLazyInitializer.getImplementation(AbstractLazyInitializer.java:195)
    at org.hibernate.proxy.pojo.javassist.JavassistLazyInitializer.invoke(JavassistLazyInitializer.java:185)
    at org.mainco.subco.organization.domain.Organization_$$_javassist_30.getState(Organization_$$_javassist_30.java)
    at org.mainco.subco.myproject.service.TeacherImportServiceImpl.saveUserObject(TeacherImportServiceImpl.java:101)
    at org.mainco.subco.myproject.service.AbstractmyprojectService.saveUsers(AbstractmyprojectService.java:226)
    at org.mainco.subco.myproject.service.AbstractmyprojectService$$FastClassByCGLIB$$d080e416.invoke(<generated>)
    at net.sf.cglib.proxy.MethodProxy.invoke(MethodProxy.java:191)
    at org.springframework.aop.framework.Cglib2AopProxy$DynamicAdvisedInterceptor.intercept(Cglib2AopProxy.java:618)
    at org.mainco.subco.myproject.service.TeacherImportServiceImpl$$EnhancerByCGLIB$$a06c7e9f.saveUsers(<generated>)
    at org.mainco.subco.myproject.service.TeacherImportServiceTest.testSaveTeachers(TeacherImportServiceTest.java:46)
    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39)
    at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25)
    at java.lang.reflect.Method.invoke(Method.java:597)
    at org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:44)
    at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:15)
    at org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:41)
    at org.junit.internal.runners.statements.InvokeMethod.evaluate(InvokeMethod.java:20)
    at org.springframework.test.context.junit4.statements.RunBeforeTestMethodCallbacks.evaluate(RunBeforeTestMethodCallbacks.java:74)
    at org.springframework.test.context.junit4.statements.RunAfterTestMethodCallbacks.evaluate(RunAfterTestMethodCallbacks.java:83)
    at org.springframework.test.context.junit4.statements.SpringRepeat.evaluate(SpringRepeat.java:72)
    at org.springframework.test.context.junit4.SpringJUnit4ClassRunner.runChild(SpringJUnit4ClassRunner.java:231)
    at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:49)
    at org.junit.runners.ParentRunner$3.run(ParentRunner.java:193)
    at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:52)
    at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:191)
    at org.junit.runners.ParentRunner.access$000(ParentRunner.java:42)
    at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:184)
    at org.springframework.test.context.junit4.statements.RunBeforeTestClassCallbacks.evaluate(RunBeforeTestClassCallbacks.java:61)
    at org.springframework.test.context.junit4.statements.RunAfterTestClassCallbacks.evaluate(RunAfterTestClassCallbacks.java:71)
    at org.junit.runners.ParentRunner.run(ParentRunner.java:236)
    at org.springframework.test.context.junit4.SpringJUnit4ClassRunner.run(SpringJUnit4ClassRunner.java:174)
    at org.eclipse.jdt.internal.junit4.runner.JUnit4TestReference.run(JUnit4TestReference.java:50)
    at org.eclipse.jdt.internal.junit.runner.TestExecution.run(TestExecution.java:38)
    at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:467)
    at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:683)
    at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.run(RemoteTestRunner.java:390)
    at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.main(RemoteTestRunner.java:197)

Maybe you forgot to add the transactional annotation to AbstractmyprojectService.saveUsers()

Note that inner calls are never proxied, so the flow:

 TeacherImportServiceTest.testSaveTeachers() ->
 AbstractmyprojectService.saveUsers() ->
 TeacherImportServiceImpl.saveUserObject()

Will not be transactional if AbstractmyprojectService.saveUsers() is not transactional at all.

EDIT

After reading your comments, I see three options to solve it:

Extract the saveUsers() method to a helper class.

Really simple, refactor your code to keep the Tx methods in one class and use it from another one via composition.

Use programmatic transactions in saveUserObject().

for example, inject the txManager and

public void saveUserObject() {
        DefaultTransactionDefinition def = new DefaultTransactionDefinition();
        def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
        TransactionStatus status = txManager.getTransaction(def);
        try {
          // the code
        }
        catch (Exception ex) {
          txManager.rollback(status);
          throw ex;
        }
        txManager.commit(status);
    }

Use AspectJ instead Spring AOP. (I think that this option is too complex only for this issue.)

Using AspectJ you replace AOP Proxies wiht the Aspect AnnotationTransactionAspect

use <tx:annotation-driven mode="aspectj"/> and choose a weaving method (compile or load time).

for load time weaving, see http://static.springsource.org/spring/docs/3.0.5.RELEASE/reference/aop.html#aop-aj-ltw

for compile time weaving with maven, see Spring / @Transactional with AspectJ is totally ignored

Related Articles