Although Hibernate can greatly facilitate development through JPA implementation, we may encounter the common Hibernate Could not initialize proxy – no Session error.

What is the “Could not initialize proxy – no Session” error?

When we try to access an object that is defined as lazy and outside the context of the open Hibernate session, we will encounter the “Could not initialize proxy – no Session” error.

In other words, this error occurs when we attempt to access a lazy object outside the open Hibernate session, resulting in the error message ‘Could not initialize proxy – no Session’.

To better understand this error, it is essential to grasp some concepts.

• The Session is the persistent context that manages objects between our application and the connected database.
• Lazy loading means that objects are not loaded into the session context until they are accessed in the code. For example, we can define a one-to-many relationship as lazy, and the collection marked as lazy will not be retrieved from the database until we perform a get operation on that attribute.
• Proxy objects are intermediaries created by Hibernate between the database and the accessed object. They serve as references to objects that may not actually exist.

Now that we have a better understanding of why this error occurs, let’s see some examples to shed more light on the reasons behind it.

Examples of Hibernate “Could not initialize proxy – no Session” error

To illustrate examples, let’s consider two entities: Company and Employee. The relationship is one-to-many, where a Company has a list of Employees.

Entity Creation

@Entity
public class Company {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column
    private int id;

    @Column
    private String name;
    
    @Column
    private String address;
    
    @OneToMany
    private Set<Employee> employees = new HashSet();
    
}

@Entity
public class Employee {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id")
    private int id;

    @Column
    private String name;

    @Column
    private String surname;
}

JPA sets the default behavior of the above relationship between Company and Employee to lazy loading.

Hibernate “Could not initialize proxy – no Session” error

Let’s trigger the Hibernate “Could not initialize proxy – no Session” error using the entities mentioned above. We’ll start a session, retrieve employees, close the session, and try to retrieve the employees again.

    Session session = sessionFactory.openSession();
    session.beginTransaction();
		
    Company companySaved = session.find(Company.class, 1L);
		
    session.getTransaction().commit();
    session.close();

    log.info(companySaved.getEmployees().size());

The above example throws a LazyInitializationException because the employees of the relationship are accessed outside the session context when they are lazily loaded.

How to solve the Hibernate “Could not initialize proxy – no Session” error

Let’s explore different approaches to avoid the LazyInitializationException.

Use FetchType.EAGER

By default, JPA employs lazy loading for relationships to load only the necessary data. However, lazy loading can lead to the “Could not initialize proxy – no Session” error. To prevent this error, we can use FetchType.EAGER to load the entire relationship in a single query, eliminating the need for additional database requests. In the previously mentioned example, the variable will load all the employees, eliminating the need for additional database queries.

With Criteria

Another way to solve the LazyInitializationException is by using Criteria. This allows us to fetch all the necessary data from the database in a single request:

Criteria criteria = session.createCriteria(Company.class);
criteria.setFetchMode("employees", FetchMode.EAGER);

Use Join Fetch

Along with Criteria, using a query annotation like @Query is one of the most optimal ways to avoid the LazyInitializationException.

For example:

@Query("SELECT c FROM COMPANY c JOIN FETCH c.employees")
public List<Company> getAll();

This is one of the best approaches (along with Criteria) because it only executes a single query to retrieve both the Company and its Employees.

Using the anti-pattern enable_lazy_load_no_trans

Enabling the property hibernate.enable_lazy_load_no_trans can avoid LazyInitializationException, but it is not recommended as it significantly impacts performance. In the given example, it would result in one select for the Company and N selects for the employees.

Although this approach addresses the symptoms of the problem, it is not a proper solution.

jpa:
    properties:
      hibernate:
        enable_lazy_load_no_trans: true

Conclusion

To solve the Hibernate “Could not initialize proxy – no Session” error, we can use different approaches as mentioned before, but we must be careful in their application. For instance, using eager loading with many child or nested entities can lead to poor performance, as well as enabling enable_lazy_load_no_trans.

To minimize performance impact, it’s best to identify and narrow down the problem as much as possible and consider using Join or Criteria queries.