I just announced the new Spring 5 modules in REST With Spring:

>> CHECK OUT THE COURSE

1. Introduction

In this short tutorial, we’ll clarify when “No Hibernate Session Bound to Thread” exception gets thrown and how to resolve it.

We’ll be focusing here on two different scenarios:

  1. using the LocalSessionFactoryBean
  2. using the AnnotationSessionFactoryBean

2. The Cause

With version 3, Hibernate introduced the concept of the contextual session and the getCurrentSession() method was added to the SessionFactory class. More information on the contextual session can be found here.

Spring has its own implementation of the org.hibernate.context.CurrentSessionContext interface – org.springframework.orm.hibernate3.SpringSessionContext (in the case of Spring Hibernate 3). This implementation requires the session to be bound to a transaction.

Naturally, classes that call getCurrentSession() method should be annotated with @Transactional either at the class level or method level. If not, the org.hibernate.HibernateException: No Hibernate Session Bound to Thread will be thrown.

Let’s have a quick look at an example.

3. LocalFactorySessionBean 

He’s the first scenario that we would be looking at in this article.

We will define a Java Spring configuration class with LocalSessionFactoryBean:

@Configuration
@EnableTransactionManagement
@PropertySource(
  { "classpath:persistence-h2.properties" }
)
@ComponentScan(
  { "org.baeldung.persistence.dao", "org.baeldung.persistence.service" }
)
public class PersistenceConfigHibernate3 {   
    // ...    
    @Bean
    public LocalSessionFactoryBean sessionFactory() {
        LocalSessionFactoryBean sessionFactory 
          = new LocalSessionFactoryBean();
        Resource config = new ClassPathResource("exceptionDemo.cfg.xml");
        sessionFactory.setDataSource(dataSource());
        sessionFactory.setConfigLocation(config);
        sessionFactory.setHibernateProperties(hibernateProperties());

        return sessionFactory;
    }    
    // ...
}

Note that we use a Hibernate configuration file (exceptionDemo.cfg.xml) here in order to map the model class. This is because the org.springframework.orm.hibernate3.LocalSessionFactoryBean does not provide the property packagesToScan, for mapping model classes.

Here’s our simple service:

@Service
@Transactional
public class EventService {
    
    @Autowired
    private IEventDao dao;
    
    public void create(Event entity) {
        dao.create(entity);
    }
}
@Entity
@Table(name = "EVENTS")
public class Event implements Serializable {
    @Id
    @GeneratedValue
    private Long id;
    private String description;
    
    // ...
 }

As we can see in the code snippet below, the getCurrentSession() method of the SessionFactory class is used to obtain the Hibernate session:

public abstract class AbstractHibernateDao<T extends Serializable> 
  implements IOperations<T> {
    private Class<T> clazz;
    @Autowired
    private SessionFactory sessionFactory;
    // ...
    
    @Override
    public void create(T entity) {
        Preconditions.checkNotNull(entity);
        getCurrentSession().persist(entity);
    }
    
    protected Session getCurrentSession() {
        return sessionFactory.getCurrentSession();
    }
}

The test below passes, demonstrating how the exception will be thrown when the class EventService containing the service method is not annotated with a @Transactional annotation:

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(
  classes = { PersistenceConfigHibernate3.class }, 
  loader = AnnotationConfigContextLoader.class
)
public class HibernateExceptionScen1MainIntegrationTest {
    @Autowired
    EventService service;
    
    @Rule
    public ExpectedException expectedEx = ExpectedException.none();
        
    @Test
    public void whenNoTransBoundToSession_thenException() {
        expectedEx.expectCause(
          IsInstanceOf.<Throwable>instanceOf(HibernateException.class));
        expectedEx.expectMessage("No Hibernate Session bound to thread, "
          + "and configuration does not allow creation "
          + "of non-transactional one here");
        service.create(new Event("from LocalSessionFactoryBean"));
    }
}

This test shows how the service method executes successfully when the EventService class is annotated with the @Transactional annotation:

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(
  classes = { PersistenceConfigHibernate3.class }, 
  loader = AnnotationConfigContextLoader.class
)
public class HibernateExceptionScen1MainIntegrationTest {
    @Autowired
    EventService service;
    
    @Rule
    public ExpectedException expectedEx = ExpectedException.none();
    
    @Test
    public void whenEntityIsCreated_thenNoExceptions() {
        service.create(new Event("from LocalSessionFactoryBean"));
        List<Event> events = service.findAll();
    }
}

4. AnnotationSessionFactoryBean

This exception can also occur when we use the org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean to create the SessionFactory in our Spring application.

Let’s look at some sample code that demonstrates this. To this extent, we define a Java Spring configuration class with AnnotationSessionFactoryBean:

@Configuration
@EnableTransactionManagement
@PropertySource(
  { "classpath:persistence-h2.properties" }
)
@ComponentScan(
  { "org.baeldung.persistence.dao", "org.baeldung.persistence.service" }
)
public class PersistenceConfig {
    //...
    @Bean
    public AnnotationSessionFactoryBean sessionFactory() {
        AnnotationSessionFactoryBean sessionFactory 
          = new AnnotationSessionFactoryBean();
        sessionFactory.setDataSource(dataSource());
        sessionFactory.setPackagesToScan(
          new String[] { "org.baeldung.persistence.model" });
        sessionFactory.setHibernateProperties(hibernateProperties());

        return sessionFactory;
    }
    // ...
}

With the same set of DAO, Service and Model classes from the previous section, we encounter the exception as described above:

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(
  classes = { PersistenceConfig.class }, 
  loader = AnnotationConfigContextLoader.class
)
public class HibernateExceptionScen2MainIntegrationTest {
    @Autowired
    EventService service;
    
    @Rule
    public ExpectedException expectedEx = ExpectedException.none();
         
    @Test
    public void whenNoTransBoundToSession_thenException() {
        expectedEx.expectCause(
          IsInstanceOf.<Throwable>instanceOf(HibernateException.class));
        expectedEx.expectMessage("No Hibernate Session bound to thread, "
          + "and configuration does not allow creation "
          + "of non-transactional one here");
        service.create(new Event("from AnnotationSessionFactoryBean"));
    }
}

If we annotate the service class with a @Transactional annotation, the service method works as expected and the test shown below passes:

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(
  classes = { PersistenceConfig.class }, 
  loader = AnnotationConfigContextLoader.class
)
public class HibernateExceptionScen2MainIntegrationTest {
    @Autowired
    EventService service;
    
    @Rule
    public ExpectedException expectedEx = ExpectedException.none();
    
    @Test
    public void whenEntityIsCreated_thenNoExceptions() {
        service.create(new Event("from AnnotationSessionFactoryBean"));
        List<Event> events = service.findAll();
    }
}

5. The Solution

It’s clear that the getCurrentSession() method of the SessionFactory obtained from Spring needs to be called from within an open transaction. Therefore, the solution is to ensure that our DAO/Service methods/classes are annotated correctly with the @Transactional annotation.

It should be noted that in Hibernate 4 and later versions, the message of the exception that is thrown for this same reason is differently worded. Instead of the “No Hibernate Session Bound to Thread”, we’d get “Could not obtain transaction-synchronized Session for current thread”.

There’s another important point to make. Along with the org.hibernate.context.CurrentSessionContext interface, Hibernate has introduced a property hibernate.current_session_context_class which can be set to the class that implements the current session context.

As stated before, Spring comes with its own implementation of this interface: the SpringSessionContext. By default it sets the hibernate.current_session_context_class property equal to this class.

As a consequence, if we explicitly set this property to something else, it disrupts Spring’s ability to manage the Hibernate session and transactions. This results in an exception as well but is different from the exception under consideration.

Summarizing, it is important to remember that we should not set the hibernate.current_session_context_class explicitly when we use Spring to manage the Hibernate session.

6. Conclusion

In this article, we looked at why an when the exception org.hibernate.HibernateException: No Hibernate Session Bound to Thread is thrown in Hibernate 3 along with some example code and how we can solve it easily.

The code for this article can be found over on Github.

I just announced the new Spring 5 modules in REST With Spring:

>> CHECK OUT THE LESSONS

Leave a Reply

Be the First to Comment!

Notify of
avatar