Unable to get @Transactional working

[vivpr]

All,

My app runs on JDK 1.5, Hibernate 3.0.5 and Spring 1.2.5

I've been unable to get the @Transactional attribute working.

The relevant part of my spring configuration is below:

    <bean id="txManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactory"/>
    </bean>

    <bean class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator"/>

    <bean class="org.springframework.transaction.interceptor.TransactionAttributeSourceAdvisor">
        <property name="transactionInterceptor" ref="transactionInterceptor"/>
    </bean>

    <bean id="transactionInterceptor" class="org.springframework.transaction.interceptor.TransactionInterceptor">
        <property name="transactionManager" ref="txManager"/>
        <property name="transactionAttributeSource">
            <bean class="org.springframework.transaction.annotation.AnnotationTransactionAttributeSource"/>
        </property>
    </bean>

My code looks like this:

public interface MyCrudService {
   @Transactional
   public void create(MyObject object);
}

and the implementation is:

public class DefaultMyCrudService implements MyCrudService {
   public void create(MyObject object) {
         currentSession().save(object);
   }
}

The currentSession() method obtains a hibernate session that has it's flush mode set to AUTO. However, if I don't use the annotation, and instead use an implementation like the one below, my tests pass:

public class DefaultMyCrudService implements MyCrudService {
   public void create(MyObject object) {
         Transaction transaction = currentSession().beginTransaction();
         currentSession().save(object);
         transaction.commit();
   }
}

For my tests, I obtain the service from spring, so I'm sure that it will get advised correctly by the TransactionInterceptor.

Am I doing something wrong here?

[dvoytenko]

hi, pls post complete code for MyCrudService implementation. Currently it's missing the source for currentSession() method. Other than possible problems in this method, i don't see any other issues in your code.

[vivpr]

Basically, MyCrudService has a session-per-thread implementation.
I think the problem is defintely here - do I have to use SessionFactoryUtils to obtain a hibernate session?

public class MyCrudService {
    private SessionFactory sessionFactory;
    private static ThreadLocal<Session> sessions = new ThreadLocal<Session>&#40;&#41;;

    public MyCrudService&#40;SessionFactory factory&#41;&#123;
        sessionFactory = factory;
    &#125;

    public void create&#40;MyObject object&#41; &#123;
        currentSession&#40;&#41;.save&#40;object&#41;;
    &#125; 

    private Session currentSession&#40;&#41; &#123;
        if &#40;sessions.get&#40;&#41; == null&#41; &#123;
            sessions.set&#40;sessionFactory.openSession&#40;&#41;&#41;;
        &#125;
        return &#40;Session&#41; sessions.get&#40;&#41;;
    &#125;

    public void closeSession&#40;&#41; &#123;
        if &#40;sessions.get&#40;&#41;!= null&#41; &#123;
            closeCurrentSession&#40;&#41;;
            clearSession&#40;&#41;;
        &#125;
    &#125;

    private void closeCurrentSession&#40;&#41; &#123;
        currentSession&#40;&#41;.flush&#40;&#41;;
        currentSession&#40;&#41;.close&#40;&#41;;
    &#125;

    void clearSession&#40;&#41; &#123;
        sessions.remove&#40;&#41;;
    &#125;
&#125;

[dvoytenko]

Keeping session in the thread's context is redundant as it's what essentially done by transactional context. In certain cases it might be dangerous too. In your particular case, I believe, you loose transactional context b/c you simply open new session w/o consulting SessioFactoryUtils which is .

The normal workflow how you normally use SessionFactory/Session in Spring is:

public void setSessionFactory(SessionFactory sessionFactory) {
  this.hibernateTemplate = new HibernateTemplate(sessionFactory);
}

public void create(MyObject object) {
  hibernateTemplate.execute(
    new HibernateCallback() {
      public Object doInHibernate(Session session)  {
         session.DO(...);
         ...
         return null;
      }
    }
  );
}

Alternatively (if you don't want to use template/callback) you can use SessionFactoryUtils for opening/releasing session to keep transactional context or extend HibernateDaoSupport.
[/quote]

[dvoytenko]

Another way, if you want to avoid using Spring's API altogether, is to setup transaction manager for DataSource and simply use:

Session = sessionFactory.openSession();
try {
  session.DO();
  ...
  session.flush();
} finally {
  session.close();
}

and let all transactions be handled on the DataSource level. This way is not completely correct from the standpoint of Hibernate's API, but it works. It also has worse performance as it potentially opens/closes session many times per transaction.

[dvoytenko]

there's actually another better way to work with sessions in the transactional context:

public void create(MyObject object) {
  sessionFactory.getCurrentSession().DO(...);
}

It also allows to avoid using Spring's API, but fully supports Spring's transaction management.