How to fix org.hibernate.LazyInitializationException - could not initialize proxy - no Session

If you using Spring mark the class as @Transactional, then Spring will handle session management.

@Transactional
public class MyClass {
    ...
}

By using @Transactional, many important aspects such as transaction propagation are handled automatically. In this case if another transactional method is called the method will have the option of joining the ongoing transaction avoiding the "no session" exception.

WARNING If you do use @Transactional, please be aware of the resulting behavior. For example, updates to entities are persisted even if you don't explicitly call save

WARNING: This solution creates a NEW TRANSACTION for every LAZY object that is fetched outside a transaction. Use at your own risk.

You can try to set the following in hibernate.cfg.xml or persistence.xml

<property name="hibernate.enable_lazy_load_no_trans">true</property>

The problem to keep in mind with this property are well explained here

The best way to handle the LazyInitializationException is to use the JOIN FETCH directive:

Query query = session.createQuery("""
    select m
    from Model m
    join fetch m.modelType
    where modelGroup.id = :modelGroupId
    """
);

Anyway, DO NOT use the following Anti-Patterns as suggested by some of the answers:

• Open Session in View
• hibernate.enable_lazy_load_no_trans

Sometimes, a DTO projection is a better choice than fetching entities, and this way, you won't get any LazyInitializationException.

if you use spring data jpa , spring boot you can add this line in application.properties

spring.jpa.properties.hibernate.enable_lazy_load_no_trans=true

WARNING: This solution has performance issues as it loads the whole tree of data at once. Use it at your own risk.

I was getting the same error for a one to many relationships for below annotation.

@OneToMany(mappedBy="department", cascade = CascadeType.ALL)

Changed as below after adding fetch=FetchType.EAGER, it worked for me.

@OneToMany(mappedBy="department", cascade = CascadeType.ALL, fetch=FetchType.EAGER)

This exception because of when you call session.getEntityById(), the session will be closed. So you need to re-attach the entity to the session. Or Easy solution is just configure default-lazy="false" to your entity.hbm.xml or if you are using annotations just add @Proxy(lazy=false) to your entity class.

This means that the object which you are trying to access is not loaded, so write a query that makes a join fetch of the object which you are trying to access.

Eg:

If you are trying to get ObjectB from ObjectA where ObjectB is a foreign key in ObjectA.

Query :

SELECT objA FROM ObjectA obj JOIN FETCH obj.objectB objB

I encountered the same issue. I think another way to fix this is that you can change the query to join fetch your Element from Model as follows:

Query query = session.createQuery("from Model m join fetch m.element where modelGroup.id = :modelGroupId")

Faced the same Exception in different use case.

Use Case : Try to read data from DB with DTO projection.

Solution: Use get method instead of load.

Generic Operation

public class HibernateTemplate {
public static Object loadObject(Class<?> cls, Serializable s) {
    Object o = null;
    Transaction tx = null;
    try {
        Session session = HibernateUtil.getSessionFactory().openSession();
        tx = session.beginTransaction();
        o = session.load(cls, s); /*change load to get*/
        tx.commit();
        session.close();
    } catch (Exception e) {
        e.printStackTrace();
    }
    return o;
}

}

Persistence Class

public class Customer {

@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = "Id")
private int customerId;

@Column(name = "Name")
private String customerName;

@Column(name = "City")
private String city;

//constructors , setters and getters

}

CustomerDAO interface

public interface CustomerDAO 
     {
   public CustomerTO getCustomerById(int cid);
     }

Entity Transfer Object Class

public class CustomerTO {

private int customerId;

private String customerName;

private String city;

//constructors , setters and getters

}

Factory Class

public class DAOFactory {

static CustomerDAO customerDAO;
static {
    customerDAO = new HibernateCustomerDAO();
}

public static CustomerDAO getCustomerDAO() {
    return customerDAO;
}

}

Entity specific DAO

public class HibernateCustomerDAO implements CustomerDAO {

@Override
public CustomerTO getCustomerById(int cid) {
    Customer cust = (Customer) HibernateTemplate.loadObject(Customer.class, cid);
    CustomerTO cto = new CustomerTO(cust.getCustomerId(), cust.getCustomerName(), cust.getCity());
    return cto;
}

}

Retrieving data: Test Class

CustomerDAO cdao = DAOFactory.getCustomerDAO();
CustomerTO c1 = cdao.getCustomerById(2);
System.out.println("CustomerName -> " + c1.getCustomerName() + " ,CustomerCity -> " + c1.getCity());

Present Data

Query and output generated by Hibernate System

Hibernate: select customer0_.Id as Id1_0_0_, customer0_.City as City2_0_0_, customer0_.Name as Name3_0_0_ from CustomerLab31 customer0_ where customer0_.Id=?

CustomerName -> Cody ,CustomerCity -> LA

This means you are using JPA or hibernate in your code and performing modifying operation on DB without making the business logic transaction. So simple solution for this is mark your piece of code @Transactional

• springBootVersion = '2.6.7'
• hibernate = 5.6.8.Final'

For me i get the error in:

MyEntity myEntity = myEntityRepository.getById(id);

I change to this:

MyEntity myEntity = myEntityRepository.findById(id).orElse(null);

and i add @ManyToOne(fetch = FetchType.EAGER) in entity

There are several good answers here that handle this error in a broad scope. I ran into a specific situation with Spring Security which had a quick, although probably not optimal, fix.

During user authorization (immediately after logging in and passing authentication) I was testing a user entity for a specific authority in a custom class that extends SimpleUrlAuthenticationSuccessHandler.

My user entity implements UserDetails and has a Set of lazy loaded Roles which threw the "org.hibernate.LazyInitializationException - could not initialize proxy - no Session" exception. Changing that Set from "fetch=FetchType.LAZY" to "fetch=FetchType.EAGER" fixed this for me.

If you are using JPQL, use JOIN FETCH is the easiest way: http://www.objectdb.com/java/jpa/query/jpql/from#LEFT_OUTER_INNER_JOIN_FETCH_

This happened to me when I was already using @Transactional(value=...) and was using multiple transaction managers.

My forms were sending back data that already had @JsonIgnore on them, so the data being sent back from forms was incomplete.

Originally I used the anti pattern solution, but found it was incredibly slow. I disabled this by setting it to false.

spring.jpa.properties.hibernate.enable_lazy_load_no_trans=false

The fix was to ensure that any objects that had lazy-loaded data that weren't loading were retrieved from the database first.

Optional<Object> objectDBOpt = objectRepository.findById(object.getId());

if (objectDBOpt.isEmpty()) {
    // Throw error
} else {
    Object objectFromDB = objectDBOpt.get();
}

In short, if you've tried all of the other answers, just make sure you look back to check you're loading from the database first if you haven't provided all the @JsonIgnore properties and are using them in your database query.

In Spring Application Just Add

@Transactional(readOnly = true)

on your Function.

Remind that import spring Transactional annotation

import org.springframework.transaction.annotation.Transactional;

Use @NamedEntityGraph. Eagar fetch will deteriorate the performance. Refer https://thorben-janssen.com/lazyinitializationexception/ for in-depth explanation.

Often the error

org.hibernate.LazyInitializationException: 
failed to lazily initialize a collection of role: 
could not initialize proxy - no Session
    at org.hibernate.collection.spi.AbstractPersistentCollection.throwLazyInitializationException

is simply because no transaction was open when a manipulation is done over an entity. So ensure that you are inside a transaction before questioning the whole entities:

• Check if your @Service is @Transactionnal, ensure that you are using the jakarta and not the javax annotation (if spring boot > 3.x), some auto import tools will use the wrong one.

• If you don't use the annotation ensure that you are inside a TransactionTemplate (that you can autowired) body like transactionTemplate.execute { myRepo.save(myEntity) }

• Check that you are truly inside a transaction with this spring boot utils near your problematic code: TransactionSynchronizationManager.isActualTransactionActive()

If you are using Grail's Framework, it's simple to resolve lazy initialization exception by using Lazy keyword on specific field in Domain Class.

For-example:

class Book {
    static belongsTo = [author: Author]
    static mapping = {
        author lazy: false
    }
}

Find further information here

In my case a misplaced session.clear() was causing this problem.

TLDR: Always serialize DTO's, avoid returning entities.

The reason for the issue is that when retrieving lazily-loaded data, first step is populate the main object, and second to retrieve the data within its proxies. For this, an open Session in Hibernate is needed.

The problem arises when the second step happens after the transaction has closed, which leads to a LazyInitializationException.

I'm going to summarize some solutions here while adding mine:

1. Avoid entity serialization, **instead serialize a dto**
2. Add `@JsonIgnore` to your `LAZY` attributes
3. Change `FetchType` to `EAGER`
4. Set `hibernate.enable_lazy_load_no_trans=true` 

Only points 1 and 2 are recommended, the other 2 aren't meant to be used at serialization phase. As they have a HUGE performance cost there, they both make a hit to the database to retrieve extra data. Option 4, actually creates a new transaction for every lazy object so please AVOID!.

My grain of sand in this question is to highly recommend to explicitly use ONLY options 1 and 2, and also FetchType.EAGER only for business logic, not as a solution for this issue.

All answers about adding JOIN FETCH (or left join fetch) are correct, I want only to add this: if you have converter be sure the getAsObject sub uses a "find" than includes in the sql the Join Fetch too. I lost much time to fix a similar problem, and the problem was in the converter.

I was getting this error in my JAX-RS application when I was trying to get all the Departments. I had to add the @JsonbTransient Annotation to the attributes of both classes. My entities are Department and Employee, and the DB relationship is Many to Many.

Employee.java

...
@ManyToMany
@JoinTable(
        name = "emp_dept",
        joinColumns = {@JoinColumn(name = "emp_id", referencedColumnName = "id")},
        inverseJoinColumns = {@JoinColumn(name = "dept_id", referencedColumnName = "id")}
)
@JsonbTransient
private Set<Department> departments = new HashSet<Department>();
...

Department.java

...
@ManyToMany(mappedBy = "departments")
@JsonbTransient
private Set<Employee> employees = new HashSet<Employee>();
...