HibernateException: No Hibernate Session Bound to Thread in Hibernate 3
Last updated: January 8, 2024
Mocking is an essential part of unit testing, and the Mockito library makes it easy to write clean and intuitive unit tests for your Java code.
Get started with mocking and improve your application tests using our Mockito guide:
Handling concurrency in an application can be a tricky process with many potential pitfalls. A solid grasp of the fundamentals will go a long way to help minimize these issues.
Get started with understanding multi-threaded applications with our Java Concurrency guide:
Spring 5 added support for reactive programming with the Spring WebFlux module, which has been improved upon ever since. Get started with the Reactor project basics and reactive programming in Spring Boot:
Since its introduction in Java 8, the Stream API has become a staple of Java development. The basic operations like iterating, filtering, mapping sequences of elements are deceptively simple to use.
But these can also be overused and fall into some common pitfalls.
To get a better understanding on how Streams work and how to combine them with other language features, check out our guide to Java Streams:
Explore Spring Boot 3 and Spring 6 in-depth through building a full REST API with the framework:
Yes, Spring Security can be complex, from the more advanced functionality within the Core to the deep OAuth support in the framework.
I built the security material as two full courses - Core and OAuth, to get practical with these more complex scenarios. We explore when and how to use each feature and code through it on the backing project.
You can explore the course here:
Spring Data JPA is a great way to handle the complexity of JPA with the powerful simplicity of Spring Boot.
Get started with Spring Data JPA through the guided reference course:
Refactor Java code safely — and automatically — with OpenRewrite.
Refactoring big codebases by hand is slow, risky, and easy to put off. That’s where OpenRewrite comes in. The open-source framework for large-scale, automated code transformations helps teams modernize safely and consistently.
Each month, the creators and maintainers of OpenRewrite at Moderne run live, hands-on training sessions — one for newcomers and one for experienced users. You’ll see how recipes work, how to apply them across projects, and how to modernize code with confidence.
Join the next session, bring your questions, and learn how to automate the kind of work that usually eats your sprint time.
Regression testing is an important step in the release process, to ensure that new code doesn't break the existing functionality. As the codebase evolves, we want to run these tests frequently to help catch any issues early on.
The best way to ensure these tests run frequently on an automated basis is, of course, to include them in the CI/CD pipeline. This way, the regression tests will execute automatically whenever we commit code to the repository.
In this tutorial, we'll see how to create regression tests using Selenium, and then include them in our pipeline using GitHub Actions:, to be run on the LambdaTest cloud grid:
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:
- using the LocalSessionFactoryBean
- 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(
{ "com.baeldung.persistence.dao", "com.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(
{ "com.baeldung.persistence.dao", "com.baeldung.persistence.service" }
)
public class PersistenceConfig {
//...
@Bean
public AnnotationSessionFactoryBean sessionFactory() {
AnnotationSessionFactoryBean sessionFactory
= new AnnotationSessionFactoryBean();
sessionFactory.setDataSource(dataSource());
sessionFactory.setPackagesToScan(
new String[] { "com.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.
