I have been suffering from infamous hibernate exception
org.hibernate.LazyInitializationException: could not initialize proxy - no Session
Now the community is cheering over
<property name="hibernate.enable_lazy_load_no_trans" value="true"/>
saying it solves the problem but USE IT WITH CAUTION.
What they mean by use it with caution? What this property actually does?
Please give me any insights.
The problem with this approach is that you can have the N+1 effect.
Imagine that you have the following entity:
public class Person{
@OneToMany // default to lazy
private List<Order> orderList;
}
If you have a report that returns 10K of persons, and if in this report you execute the code person.getOrderList() the JPA/Hibernate will execute 10K of queries. This is the N+1 effect, you will have no control about all the queries that will be executed.
Imagine now that Order is like below:
public class Order{
@OneToMany // default to lazy
private List<EmailSent> emailSentList;
}
Imagine now that you have a iteration with the person.getOrderList() and for every Order orderyou will do a order.getEmailSentList(). Can you see the problem now?
For LazyInitializationException you can have some solutions:
select p from Person p join fetch p.orderList. With this query you will have your list loaded from the database and will not have the N+1 effect. The problem is that you will need to write a JPQL for each case.If you still have any problem, check these links:
Join Fetch is not useful! We have a many to one relation, we need to use some conditions on the join means something like this: LEFT JOIN e.clientDatasource cd ON cd.isActive = TRUE AND cd.isDeleted = FALSE and Fetch does not work with it, if we use LEFT JOIN FETCH it will throw an exception saying fetch can not accompany with join condition!. We can not have these two conditions on the query because the cd might be null and then it will not retrieve the e as well. –
Magpie This goes against how we can take advantage of Hibernate's enforcement of repeatable read semantics with the Session concept. When an object is first loaded and if the object is referenced again within the life of the session, then the same object is returned IRRESPECTIVE of whether this object has changed in the DB. This is the repeatable read semantics provided automatically by hibernate.
With this setting, you have no session providing this guarantee, so if you now access this data you will be getting the latest version of the data.
This might be fine. But consider the scenario where this object is held in some place for a long time and the data has changed considerably, so that the lazily fetched data is much different that the data already loaded when the session was alive. This is what you need to be concerned about.
To put it simple you can safely use this setting if your program is not affected by: How stale the data that was already fetched when in session to the data that will be fetched lazily out of session
But if this (your program is exposed to timing issues, when it might work fine one time and fail another time) is a concern, then fetch all the necessary data while in session.
The best way to solve the LazyInitializationException is to use the JOIN FETCH directive in your entity queries.
EAGER loading is bad for performance. Also, there are anti-patterns such as:
Which you should never use since they either require the database connection to be open for the UI rendering (Open Session in View), or a database connection is needed for every lazy association that is fetched outside of the initial Persistence Context (hibernate.enable_lazy_load_no_trans).
Sometimes, you don't even need entities, and a DTO projection is even better.
Probably because there are better solutions, like @Transactional, where opening and closing sessions follows a very common pattern of "open a session then wrap everything in a try-catch-finally; catch rolls back and finally closes the session." This annotation is typically at the request-level for web apps and services.
Or if you need more granular control you can open sessions manually using a SessionFactory.
And as others have mentioned, lazy-loading is something you need to be aware of. It's not a silver bullet but it can be very helpful. Generally, if your apps are designed to have many small requests then its ok.
Eager loading can also be very bad. For example, when your object model has lots of many-to-many relationships but your requests don't use data more than one level deep.
Or you can just forget the whole thing for now. Use lazy loading until it becomes an issue. And if it does, you would have been better of with Mybatis anyway.
© 2022 - 2024 — McMap. All rights reserved.