Hibernate SessionFactory

Hibernate SessionFactory is the factory class through which we get sessions and perform database operations.

Hibernate SessionFactory

Hibernate SessionFactory provides three methods through which we can get Session object – getCurrentSession(), openSession() and openStatelessSession().

Hibernate getCurrentSession

The Hibernate SessionFactory getCurrentSession() method returns the session bound to the context. But for this to work, we need to configure it in the Hibernate configuration file like below:

<property name="hibernate.current_session_context_class">thread</property>

If it’s not configured to thread, then we will get the following exception:

Exception in thread "main" org.hibernate.HibernateException: No CurrentSessionContext configured!
    at org.hibernate.internal.SessionFactoryImpl.getCurrentSession(SessionFactoryImpl.java:1012)
    at com.journaldev.hibernate.main.HibernateSessionExample.main(HibernateSessionExample.java:16)

Since this session object belongs to the Hibernate context, we don’t need to close it. Once the session factory is closed, this session object gets closed. Hibernate Session objects are not thread safe, so we should not use them in a multi-threaded environment. We can use them in a single-threaded environment because it’s relatively faster than opening a new session.

Hibernate SessionFactory openSession

The Hibernate SessionFactory openSession() method always opens a new session. We should close this session object once we are done with all the database operations. We should open a new session for each request in a multi-threaded environment. For web application frameworks, we can choose to open a new session for each request or for each session based on the requirement.

Hibernate openStatelessSession

The Hibernate SessionFactory openStatelessSession() method returns an instance of StatelessSession. There is another overloaded method where we can pass a java.sql.Connection object to get a stateless session object from Hibernate. StatelessSession in Hibernate does not implement a first-level cache and doesn’t interact with any second-level cache. Since it’s stateless, it doesn’t implement transactional write-behind or automatic dirty checking or do cascading operations to associated entities. Collections are also ignored by a stateless session. Operations performed via a stateless session bypass Hibernate’s event model and interceptors. It’s more like a normal JDBC connection and doesn’t provide any benefits that come from using the Hibernate framework.

However, a stateless session can be a good fit in certain situations. For example, where we are loading bulk data into a database and we don’t want the Hibernate session to hold huge data in first-level cache memory. A simple program showing Hibernate SessionFactory methods usage is given below:

package com.journaldev.hibernate.main;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.StatelessSession;

import com.journaldev.hibernate.util.HibernateUtil;

public class HibernateSessionExample {

    public static void main(String[] args) {
        
        SessionFactory sessionFactory = HibernateUtil.getSessionFactory();
        
        //Current Session - no need to close
        Session currentSession = sessionFactory.getCurrentSession();
        
        //open new session
        Session newSession = sessionFactory.openSession();
        //perform db operations
        
        //close session
        newSession.close();
        
        //open stateless session
        StatelessSession statelessSession = sessionFactory.openStatelessSession();
        //perform stateless db operations
        
        //close session
        statelessSession.close();
        
        //close session factory
        sessionFactory.close();
    }

}

That’s all for SessionFactory in Hibernate and its different methods to obtain session objects.

Conclusion

Hibernate SessionFactory is a powerful tool for managing database sessions. By understanding the differences between getCurrentSession(), openSession(), and openStatelessSession(), developers can choose the right approach based on their application’s requirements, ensuring both performance and scalability.