Complete Guide to Accessing Hibernate SessionFactory in Spring Boot

Core Concepts and Background

In modern Java application development with Spring Boot, Hibernate serves as a primary implementation of the JPA specification, offering robust Object-Relational Mapping (ORM) capabilities. Spring Boot simplifies Hibernate integration through auto-configuration, but in advanced scenarios, developers may need direct access to the underlying Hibernate SessionFactory rather than using the standard JPA EntityManager. This typically occurs when leveraging Hibernate-specific features, such as custom queries, cache management, or configuration options unique to Hibernate.

Primary Implementation Method

Based on community best practices, the most direct and reliable approach is using the unwrap method of the JPA EntityManagerFactory. Spring Boot automatically creates and manages the EntityManagerFactory Bean, which is essentially a wrapper for the Hibernate SessionFactory. By calling unwrap(SessionFactory.class), you can safely retrieve the underlying Hibernate instance.

Below is a complete service class example demonstrating how to inject and use SessionFactory in a Spring component:

package net.andreaskluth.hibernatesample;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class SomeService {

  private SessionFactory hibernateFactory;

  @Autowired
  public SomeService(EntityManagerFactory factory) {
    if(factory.unwrap(SessionFactory.class) == null){
      throw new NullPointerException("factory is not a hibernate factory");
    }
    this.hibernateFactory = factory.unwrap(SessionFactory.class);
  }

}

In this implementation, the constructor receives the Spring-injected EntityManagerFactory via the @Autowired annotation. It then uses the unwrap method to attempt to obtain the SessionFactory. If the return value is null, an exception is thrown, ensuring the factory is indeed a Hibernate implementation. This method avoids potential class cast exceptions and provides better type safety.

Configuration and Version Considerations

For earlier versions of Spring Boot and Hibernate, additional configuration may be necessary. In combinations of Spring Boot 1.x with Hibernate 4, specific properties need to be set in the application.properties file:

spring.jpa.properties.hibernate.current_session_context_class=org.springframework.orm.hibernate4.SpringSessionContext

Additionally, define HibernateJpaSessionFactoryBean in a configuration class:

@Bean
public HibernateJpaSessionFactoryBean sessionFactory() {
    return new HibernateJpaSessionFactoryBean();
}

With this configuration, you can directly inject SessionFactory in service classes using the @Autowired annotation. For Spring Boot 1.5 and above with Hibernate 5, the configuration differs slightly:

spring.jpa.properties.hibernate.current_session_context_class=org.springframework.orm.hibernate5.SpringSessionContext

The Bean definition in the configuration class also requires adjustment:

@Bean
public HibernateJpaSessionFactoryBean sessionFactory(EntityManagerFactory emf) {
    HibernateJpaSessionFactoryBean fact = new HibernateJpaSessionFactoryBean();
    fact.setEntityManagerFactory(emf);
    return fact;
}

These configurations ensure proper integration of Hibernate's session context with Spring's transaction management.

Alternative Implementation Approaches

Beyond direct unwrapping in service classes, another common pattern is creating a SessionFactory Bean in Spring configuration via a @Bean method. This approach allows uniform use of the same SessionFactory instance throughout the application via dependency injection. The implementation code is as follows:

import javax.persistence.EntityManagerFactory;
import org.hibernate.SessionFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;

....

@Autowired
private EntityManagerFactory entityManagerFactory;

@Bean
public SessionFactory getSessionFactory() {
    if (entityManagerFactory.unwrap(SessionFactory.class) == null) {
        throw new NullPointerException("factory is not a hibernate factory");
    }
    return entityManagerFactory.unwrap(SessionFactory.class);
}

The advantage of this method is centralizing the creation logic of SessionFactory, aligning with Spring's configuration best practices. Developers can choose the appropriate scheme based on project structure and personal preference.

Summary and Best Practice Recommendations

In most modern Spring Boot applications, it is recommended to use the EntityManagerFactory.unwrap(SessionFactory.class) method to obtain the Hibernate SessionFactory. This approach is straightforward, requires no additional configuration, and integrates seamlessly with Spring's dependency injection mechanism. For scenarios requiring backward compatibility with older versions or specific configurations, refer to the version-specific settings mentioned above. Regardless of the chosen method, it is advisable to include appropriate null checks to ensure code robustness. By effectively utilizing these techniques, developers can leverage the full power of Hibernate while enjoying the conveniences of Spring Boot.