EntityManagerFactory vs. SessionFactory

1. Introduction

In this tutorial, we’ll explore the similarities and differences between SessionFactory and EntityManagerFactory.

As their names suggest, both are factory classes used to create objects for database communication. Beyond just creating objects, they offer additional features to help us interact with the database.

In the following sections, we’ll examine the distinctions between these two factory classes so we can have a better understanding of when to use them.

2. What Is EntityManagerFactory?

The Java Persistence API (JPA) serves as a specification for managing persistent data within Java applications. It provides a standard way to interact with relational databases. EntityManager, as a core interface of JPA, is used to interact with the persistence context and manage the lifecycle of entities. It provides lightweight instances with methods for basic CRUD operations.

That said, we notice that we’ll frequently require EntityManager instances, and that is where EntityManagerFactory will help us. EntityManagerFactory is a JPA interface that creates instances of EntityManager, enabling interaction with the persistence context in a thread-safe manner.

2.1. Setup Process

As a first step, let’s begin by defining an entity:

@Entity(name = "persons")
public class Person {
    @Id
    @GeneratedValue(strategy= GenerationType.IDENTITY)
    private Integer id;
    private String name;
    private String email;

    // omitted getters and setters
}

There are several ways to set up configuration, we’ll cover the approach by using the persistence.xml file. To begin, we need to create a new file inside the resource/META-INF folder and define connection details:

<persistence-unit name="com.baeldung.sfvsemf.persistence_unit" transaction-type="RESOURCE_LOCAL">
    <description>Persistence Unit for SessionFactory vs EntityManagerFactory code example</description>
    <class>com.baeldung.sfvsemf.entity.Person</class>
    <exclude-unlisted-classes>true</exclude-unlisted-classes>
    <properties>
        <property name="hibernate.hbm2ddl.auto" value="update"/>
        <property name="hibernate.show_sql" value="true"/>
        <property name="hibernate.generate_statistics" value="false"/>
        <property name="hibernate.dialect" value="org.hibernate.dialect.H2Dialect"/>
        <property name="jakarta.persistence.jdbc.driver" value="org.h2.Driver"/>
        <property name="jakarta.persistence.jdbc.url" value="jdbc:h2:mem:db2;DB_CLOSE_DELAY=-1"/>
        <property name="jakarta.persistence.jdbc.user" value="sa"/>
        <property name="jakarta.persistence.jdbc.password" value=""/>
    </properties>
</persistence-unit>

Note that for simplicity we are using H2 in-memory database in this example, but it’s not limited to it. Most relational databases will work the same way, we just need to ensure that the correct dialect and driver class are used.

2.2. Usage Example

With configuration completed, the process of creating EntityManager objects with EntityManagerFactory is simple.

Using EntityManagerFactory can be risky if not done properly as it’s expensive to create. In other words, EntityManagerFactory instantiation requires a lot of resources and because of that, it’s recommended to create them as a Singleton class.

While we won’t go into much detail to illustrate usage, we’ll cover basic operations with a code example. We won’t create singleton instead we’ll just instantiate EntityManagerFactory, create an EntityManager object, and then proceed to use it for simple database operations.

Let’s see how that looks in practice:

@Test
public void givenEntityManagerFactory_whenPersistAndFind_thenAssertObjectPersisted() {
    EntityManagerFactory entityManagerFactory =
      Persistence.createEntityManagerFactory("com.baeldung.sfvsemf.persistence_unit");
    EntityManager entityManager = entityManagerFactory.createEntityManager();

    try {
        entityManager.getTransaction().begin();
        Person person = new Person("John", "[email protected]");
        entityManager.persist(person);
        entityManager.getTransaction().commit();

        Person persistedPerson = entityManager.find(Person.class, person.getId());
        assertEquals(person.getName(), persistedPerson.getName());
        assertEquals(person.getEmail(), persistedPerson.getEmail());
    } catch (Exception ex) {
        entityManager.getTransaction().rollback();
    } finally {
        entityManager.close();
        entityManagerFactory.close();
    }
}

3. What Is SessionFactory?

A popular ORM framework, Hibernate, uses SessionFactory as its factory class to create and manage Session instances. Same as EntityManagerFactory, the SessionFactory also offers a thread-safe way to handle database connections and CRUD operations.

In contrast, a Session is similar to an EntityManager as it interacts with a database, manages transactions, and handles the complete lifecycle of an entity.

3.1. Setup Process

Before we proceed with the setup process we’ll assume that we have a working knowledge of configuring and using Hibernate as we won’t go with an in-depth explanation in this article. If not, refer to our Hibernate-related articles to discover more.

To demonstrate how SessionFactory works, we utilize the same entity class as in the previous example. Hibernate primarily uses the hibernate.cfg.xml file for configuration, let’s add it to our resources:

<hibernate-configuration>
    <session-factory>
        <property name="hibernate.connection.driver_class">org.h2.Driver</property>
        <property name="hibernate.connection.url">jdbc:h2:mem:db2;DB_CLOSE_DELAY=-1</property>
        <property name="hibernate.connection.username">sa</property>
        <property name="hibernate.connection.password"></property>
        <property name="hibernate.dialect">org.hibernate.dialect.H2Dialect</property>
        <property name="hibernate.hbm2ddl.auto">update</property>
        <property name="hibernate.show_sql">true</property>
        <mapping class="com.baeldung.sfvsemf.entity.Person"/>
    </session-factory>
</hibernate-configuration>

3.2. Usage Example

Before using SessionFactory, it’s important to mention that, similarly to EntityManagerFactory it’s expensive to create. A general suggestion is to use them as singleton instances.

Once we configured SessionFactory, let’s check how to use it to create a Session instance and perform basic database operations:

@Test
void givenSessionFactory_whenPersistAndFind_thenAssertObjectPersisted() {
    SessionFactory sessionFactory = new Configuration().configure().buildSessionFactory();
    Session session = sessionFactory.openSession();
    Transaction transaction = null;

    try {
        transaction = session.beginTransaction();

        Person person = new Person("John", "[email protected]");
        session.persist(person);
        transaction.commit();

        Person persistedPerson = session.find(Person.class, person.getId());
        assertEquals(person.getName(), persistedPerson.getName());
        assertEquals(person.getEmail(), persistedPerson.getEmail());
    } catch (Exception ex) {
        if (transaction != null) {
            transaction.rollback();
        }
    } finally {
        session.close();
        sessionFactory.close();
    }
}

4. Comparing EntityManagerFactory and SessionFactory

Both factories share several similarities and serve the same purpose. Their primary role is to provide instances for database communication. We should explore other similarities, differences, and use case scenarios where we can utilize them.

4.1. Key Similarities and Differences

In addition to the responsibility of creating session instances, there are other similarities:

• Both provide supplementary query capabilities with CriteriaBuilder and HibernateCriteriaBuilder.
• They support transactions helping us maintain data integrity.
• We must manage them carefully because they are resource-intensive, thus it’s best to instantiate them once and reuse the instance.
• Their thread-safe design allows for concurrent access.

If we look at their implementations, we notice that in fact, SessionFactory inherits the EntityManagerFactory. However, there are some key differences between the two. The main difference is that SessionFactory is a Hibernate-specific concept, while EntityManagerFactory is a standard JPA interface.

Another important difference is that Hibernate supports second-level caching. It operates at the SessionFactory level, allowing cached data to be shared across all sessions. This feature is specific to Hibernate and isn’t available in the JPA specification.

4.2. Use Case Comparison

EntityManagerFactory should be used when building applications that need to be vendor-independent, in other words, we can easily swap underlying providers (Hibernate, EclipseLink, OpenJpa, etc.). If we prefer Hibernate or some of its specific features, such as second-level caching and batch querying, we should use SessionFactory.

In summary, EntityManagerFactory tends to be more flexible and portable across various JPA implementations, whereas SessionFactory is tightly coupled to Hibernate.

For a better understanding, let’s do a side-by-side comparison.

5. Conclusion

In this article, we explored the setup and usage of the EntityManagerFactory and SessionFactory. We learned that both serve the essential purpose of creating session objects for database communication. It became clear that SessionFactory is Hibernate’s specific adaptation of the standard EntityManagerFactory.

In cases where we desire Hibernate features, it’s a good choice to use SessionFactory. However, for a more standardized approach, we should lean towards JPA specification meaning that EntityManagerFactory is a better option.