Best way to initialize LAZY entities and collection proxies with JPA and Hibernate - Vlad Mihalcea (2023)

Last change:

Follow @vlad_mihalcea

Imagine having a tool that can automatically detect JPA and Hibernate performance issues. Wouldn't that be just great?

Gut,Hypersistence OptimizerIt's that tool! And it works with Spring Boot, Spring Framework, Jakarta EE, Java EE, Quarkus or Play Framework.

So enjoy spending your time doing the things you love instead of troubleshooting performance issues on your production system on a Saturday night!

In this article, we will look at the best way to initialize LAZY proxies and collections when using JPA and Hibernate.

I decided to write this article because there are too many resources on the internet that tempt the reader to use inconvenient and inefficient practices.

The best way to initialize LAZY proxies and collections when using JPA and#Hibernate.@vlad_mihalcea

— Java (@java)December 6, 2018

Suppose we have a fatherto postEntity that has a bidirectional@One to manyassociation with thepost commentsecondary entity.

(Video) The best way to fetch entities with JPA and Hibernate

Thatto postThe entity is mapped as follows:

@Entity(name = "Post")@Table(name = "post")@Cache(use = CacheConcurrencyStrategy.READ_WRITE)public class Publicar { @Id private Long id; título de cadena privado; @OneToMany( mappedBy = "post", cascade = CascadeType.ALL, orphanRemoval = true ) @Cache(usage = CacheConcurrencyStrategy.READ_WRITE) private List<PostComment> comments = new ArrayList<>(); getId largo público () { ID de retorno; } public Post setId(Long id) { = id; devolver esto; } public String getTitle() { Retorno-Titel; } public Post setTitle(String title) { this.title = title; devolver esto; } public List<PostComment> getComments() { Entwicklerkommentare; } public void addComment (Kommentar später als Kommentar) { kommentare.add (Kommentar); comentario.setPost(esto); } public void removeComment(Comentario posterior al comentario) { comments.remove(commentario); commentario.setPost(null); } @Override public boolean equals(Object o) { if (this == o) return true; if (!(o instancia de Post)) devuelve falso; return id != null && id.equals(((Post) o).getId()); } @Override public int hashCode() { return getClass().hashCode(); }}

There are several aspects ofto postEntity mapping worth explaining:

  • Thatto postentity uses theREAD WRITESecond level cache concurrency strategy that workswrite usingAway.
  • Setters follow aFluid style APIwhich is compatible with Hibernate.
  • Because the@One to manyThe association is bi-directional, we provide add/remove utility methodsMake sure both sides of the partnership stay in sync. If both ends of a bi-directional association are not synchronized, it can cause problems that are very difficult to trace.
  • ThatHash-CodeThe method returns a constant value because the entity identifier is used for equality checks. That is aTechnique I introduced 2 years agosince it was previously assumed that the entity identifier cannot be used when comparing the logical equivalence of the JPQ entity.

Thatpost commentThe entity is mapped as follows:

@Entity(name = "PostComment")@Table(name = "post_comment")@Cache(usage = CacheConcurrencyStrategy.READ_WRITE)public class PostComment { @Id private Long id; private string validation; @ManyToOne(fetch = FetchType.LAZY) private post post; public long getId() { return id; } public PostComment setId(Long id) { = id; return that; } public String getReview() { return review; } public PostComment setReview(String review) { = review; return that; } public post getPost() { return post; } public PostComment setPost(Post Post) { = post; return that; } @Override public boolean equals(Object o) { if (this == o) return true; if (!(or PostComment instance)) returns false; return id != null && id.equals(((PostComment) o).id); } @Override public int hashCode() { return getClass().hashCode(); } @Override public String toString() { return "PostComment{" + "id=" + id + ", review='" + review + ''' + '}'; }}

Note that the strategy for getting the@ManyForOneThe association is founded inFetchType.LAZYbecause by default@ManyForOnej@love to loveAssociations are eagerly sought and this can lead toN+1 query problemsamong other performance issues. For more information, seethis article.

A lazily loaded entity or collection isreplaced by a proxybefore looking up the entity or collection. The proxy can be initialized by accessing any entity or collection item property, or by using theHibernate.initializeMethod.

Now consider the following example:"Clear second level cache");entityManager.getEntityManagerFactory().getCache().evictAll();"Load post comment");Post comment comment = entityManager.find( PostComment. class, 1L );assertEquals("Must read!", comment.getReview());Post Post = comment.getPost();"Post Feature Class: {}", post.getClass( ). getName() ) ;Hibernate.initialize(post);assertEquals( "High Performance Java Persistence", post.getTitle());

First we clear the second level cache because unless you explicitly enable the second level cache and configure a provider, Hibernate will not use the second level cache.

When running this test case, Hibernate executes the following SQL statements:

-- Clear second level cache -- Remove entity cache:$Post -- Remove entity cache: .fetching.HibernateInitializeTest$PostComment -- Fetch of a PostCommentSELECT AS id1_1_0_, pc.post_id AS post_id3_1_0_, AS review2_1_0_FROM post_comment pcWHERE Post entity class: .hibernate.fetching.HibernateInitializeTest$Post $HibernateProxy $5 LVxadxFSELECT LIKE id1_0_0_, p.title LIKE title2_0_0_FROM post pWHERE

We can see that the second level cache was cleared successfully and that after retrieving thepost commentbeings, theto postEntity is represented by aHibernateProxyInstance containing only theto postEntity identifier retrieved from theMessage IDcolumn ofpost commentrow of the database table.

Well, based on the call to theHibernate.initializemethod, a secondary SQL query is run to get theto postunit, and that is not very efficient and can lead toN+1 query problems.

So unless you're using the second-level cache, it's not a good idea to get lazy associations with secondary SQL queries either by iterating over them or using themHibernate.initializeMethod.

(Video) VLAD MIHALCEA - Java Persistence and Hibernate Tips that can boost up your application performance

In the above case, thepost commentshould be searched along with yourto postassociation with theBECOME A MEMBERJPQL Policy."Clear second level cache");entityManager.getEntityManagerFactory().getCache().evictAll();"Load post comment");post comment comment = entityManager.createQuery( "select pc " + "from PostComment pc" + "join fetch" + "where = :id", PostComment.class).setParameter("id", 1L).getSingleResult();assertEquals(" A must be read !", comment.getReview());Post Post = comment.getPost();"Post Entity Class: {}", post.getClass().getName());assertEquals( " High Performance Java Persistence ", post.getTitle());

This time, Hibernate executes a single SQL statement and we no longer run the risk of encountering N+1 query problems:

-- Clear second level cache -- Remove entity cache:$Post -- Remove entity cache: .fetching.HibernateInitializeTest$PostComment -- Fetch of a PostCommentSELECT AS id1_1_0_, AS id1_0_1_, pc.post_id AS post_id3_1_0_, AS review2_1_0_, p.title AS title2_0_1_FROM post_comment pcINNER JOIN post p id= ON pc p.idWHERE =1- - Post entity class:$Post

Note that theto postthe entity class is not aHibernateProxymore because theto postThe map is retrieved at query time and initialized as a POJO.

So let's see whenHibernate.initializeIt's really worth using the second-level cache:"Loading a PostComment");Comment PostComment = entityManager.find( PostComment.class, 1L);assertEquals("A must read!", comment.getReview());Post post = comment.getPost();"Post Entity Class: {}", post.getClass().getName());Hibernate.initialize(post);assertEquals("High Performance Java Persistence", post.getTitle());

This time we're not removing the second level cache regions anymore and since we're using themREAD WRITEWith the cache concurrency strategy, entities are cached right after their persistence, so there is no need to run a SQL query when running the test case above:

-- PostComment speichern -- Cache-Treffer: region = `$PostComment`, key = `$PostComment# 1 `-- Proxy-Klasse:$Post$HibernateProxy$rnxGtvMK-- Cache-Treffer: region = `$ Post`, clave = `$Post#1`

Bothpost commentand theto postMappings are retrieved from the second-level cache, as shown incache hitlog messages.

So if you're using the second level cache, it's ok to use thatinitialize.hibernationfor additional associations, you must meet your business use case. In this case, each call should run very quickly even if you have N+1 cache calls because the second level cache is configured correctly and the data is returned from memory.

ThatHibernate.initializeIt can also be used for collections. Since the second level cache collections are now full read, they will be cached on first load when running the following test case:"Loading a post");Post Post = entityManager.find(Post.class, 1L);List<PostComment> comments = post.getComments();"Collection of classes: {}", Comments .getClass().getName());Hibernate.initialize(Comments);"Post comments: {}", Comments);

Hibernate runs a SQL query to load itpost commentCollection:

-- Laden eines Posts: Cache-Match: region = `$Post`, key = `$Post#1 ` -- Sammlungsklasse: org.hibernate.collection.internal.PersistentBag- Cachetreffer, aber Element kann nicht gelesen werden/ist ungültig: region = `$ Post.comments`, key = `$Post.comments#1`SELECT pc.post_id AS post_id3_1_0_, AS id1_1_0_, AS id1_1_1_, pc.post_id LIKE post_id3_1_1_, LIKE review2_1_1_FROM post_comment pcWHERE pc.post_id=1-- Post-Kommentare: [ PostComment{id=1, review='Awesome!'}, PostComment{id=2, review='Awesome!'} , PostComment{id=3, review= '5 Sterne'}]

However, if thepost commentThe collection is already cached:

doInJPA(entityManager -> { Public publication = entityManager.find(Post.class, 1L); assertEquals(3, post.getComments().size());});

Running the above test case only allows Hibernate to retrieve all data from the cache:

-- Laden eines Posts: Cache-Match: region = `$Post`, key = `$Post#1 ` – Sammlungsklasse: org.hibernate.collection.internal.PersistentBag – Cache-Treffer: region = `$Post.comments`, key = `com.vladmihalcea .book . hpjp.hibernate.fetching.HibernateInitializeTest$Post.comments#1`-- Cache-Match: region = `$PostComment`, key = ` . hibernate.fetching.HibernateInitializeTest$PostComment#1`-- Cache-Match: region = `$PostComment`, key = ` .hibernate.fetching . HibernateInitializeTest$PostComment#2`-- Cache-Übereinstimmung: region = ` hibernate.fetching.HibernateInitializeTest$PostComment`, key = `com.vladm$PostComment#3`

If you liked this article, I bet you will love mineBuchjvideo coursein addition.

(Video) The best way to map a @OneToOne relationship with JPA and Hibernate

Best way to initialize LAZY entities and collection proxies with JPA and Hibernate - Vlad Mihalcea (2)Best way to initialize LAZY entities and collection proxies with JPA and Hibernate - Vlad Mihalcea (3)Best way to initialize LAZY entities and collection proxies with JPA and Hibernate - Vlad Mihalcea (4)

ThatHibernate.initializeThe method is useful when loading a proxy entity or collection stored in the second level cache. If the underlying entity or collection is not cached, loading the proxy with a secondary SQL query is less efficient than loading the lazy association from scratch with aBECOME A MEMBERpolicy.

Follow @vlad_mihalcea

Best way to initialize LAZY entities and collection proxies with JPA and Hibernate - Vlad Mihalcea (5)

(Video) High-Performance Hibernate (Vlad Mihalcea)

Best way to initialize LAZY entities and collection proxies with JPA and Hibernate - Vlad Mihalcea (6)

(Video) The best way to log SQL statements with JPA and Hibernate

Best way to initialize LAZY entities and collection proxies with JPA and Hibernate - Vlad Mihalcea (7)

Best way to initialize LAZY entities and collection proxies with JPA and Hibernate - Vlad Mihalcea (8)



How do you initialize a lazy collection in JPA? ›

5 ways to initialize lazy associations and when to use them
  1. 1 1. Call a method on the mapped relation.
  2. 2 2. Fetch Join in JPQL.
  3. 3 3. Fetch Join in Criteria API.
  4. 4 4. Named Entity Graph.
  5. 5 5. Dynamic Entity Graph.
  6. 6 Conclusion.

How do you configure JPA with Hibernate? ›

Development Steps
  1. Create a Simple Maven Project.
  2. Project Directory Structure.
  3. Add jar Dependencies to pom.xml.
  4. Creating the JPA Entity Class(Persistent class)
  5. Create a JPA configuration file.
  6. Create a JPA helper class.
  7. Create the Main class and Run an Application.

Which is better to use JPA or Hibernate? ›

JPA is a standard, while Hibernate is not. In hibernate, we use Session for handling the persistence of data, while in JPA, we use Entity Manager. The query language in Hibernate is Hibernate Query language, while in JPA, the query language is Java Persistence query language. Hibernate is one of the most JPA providers.

How do you initialize a lazy load? ›

Implementing a Lazy-Initialized Property

To implement a public property by using lazy initialization, define the backing field of the property as a Lazy<T>, and return the Value property from the get accessor of the property. The Value property is read-only; therefore, the property that exposes it has no set accessor.

Which method will provide lazy initialization? ›

Using the initElements method, one can initialize all the web elements located by @FindBy annotation. lazy initialization: AjaxElementLocatorFactory is a lazy load concept in Page Factory. This is used to identify web elements only when used in any operation or activity.

Is lazy initialization good? ›

Lazy initialization is useful when calculating the value of the field is time consuming and you don't want to do it until you actually need the value. So it's often useful in situations where the field isn't needed in many contexts or we want to get the object initialized quickly and prefer any delay to be later on.

Which is the correct way to configure JPA repository? ›

Creating a JPA Repository
  1. Step 1: Create an interface with the name ExchangeValueRepository and extends the JpaRepository class. ...
  2. Step 2: Open CurrencyExchageController. ...
  3. Step 3: Create a query method in the ExcahngeValueRepository. ...
  5. Step 4: In the CurrencyExchangeController.

Can we use both JPA and Hibernate? ›

Spring JPA is a standard and there are vendors providing implementation for it. Hibernate is one of them. So basically you can simply use JPA instead of mix of both.

What is the advantage of using JPA over Hibernate? ›

So your choices are this: hibernate, toplink, etc... The advantage to JPA is that it allows you to swap out your implementation if need be. The disadvantage is that the native hibernate/toplink/etc... API may offer functionality that the JPA specification doesn't support.

What are the disadvantages of JPA? ›

The disadvantages are:
  • Verbose Code: After receiving the database query result we need to instantiate and populate the object manually, invoking all the required “set” methods. ...
  • Fragile Code: If a database table column changes its name it will be necessary to edit all the project queries that uses this column.
Sep 6, 2014

How can I make JPA faster? ›

5 tips to write efficient queries with JPA and Hibernate
  1. 1.1 1. Choose a projection that fits your use case.
  2. 1.2 2. Avoid eager fetching in your mapping definition.
  3. 1.3 3. Initialize all required associations in your query.
  4. 1.4 4. Use pagination when you select a list of entities.
  5. 1.5 5. Log SQL statements.

How to do lazy initialization in Spring Boot? ›

4. Enable Lazy Initialization
  1. 4.1. Using SpringApplicationBuilder. Another way to configure the lazy initialization is to use the SpringApplicationBuilder method: SpringApplicationBuilder(Application.class) .lazyInitialization(true) .build(args) .run(); ...
  2. 4.2. Using SpringApplication.
Apr 2, 2021

What is lazy initialization in Hibernate? ›

LazyInitializer is a Hibernate component that helps to generate proxy objects for Entities and can also be used to fetch the underlying entities of these proxy objects.

How to make lazy initialization in Java? ›

The concept of delaying the loading of an object until one needs it is known as lazy loading.
Lazy Initialization
  1. // A Java program that shows the.
  2. // Lazy Initialization.
  3. // import statements.
  4. import java.util.Map;
  5. import java.util.HashMap;
  6. import java.util.Map.Entry;
  7. enum CarsType.
  8. {

Why is lazy vs eager initialization preferred? ›

It's better to use lazy instantiation for expensive objects that you might never use. However, if we are working with an object that we know will be used every time the application is started, and if the object's creation is expensive, in terms of system resources, then it's better to use eager instantiation.

Which design pattern does Hibernate use for lazy loading? ›

The lazy loading design pattern in Hibernate is achieved by using a virtual proxy object.

Which method uses lazy loading in the Hibernate session? ›

Hibernate applies lazy loading approach on entities and associations by providing a proxy implementation of classes. Hibernate intercepts calls to an entity by substituting it with a proxy derived from an entity's class.

Is __ init __ important? ›

The __init__ function is called every time an object is created from a class. The __init__ method lets the class initialize the object's attributes and serves no other purpose. It is only used within classes.

Why zero initialization is not good initialization technique? ›

Conclusion. Zero initialization causes the neuron to memorize the same functions almost in each iteration. Random initialization is a better choice to break the symmetry. However, initializing weight with much high or low value can result in slower optimization.

Should I lazy load all components? ›

Benefits of lazy loading React components

Lazily loading components is a great way to improve the performance of your app. It is also a great way to reduce the size of your bundle. It is also a great way to reduce the number of components that are loaded.

Which method of the JPA EntityManager would you use to force synchronizing database? ›

To force synchronization of the managed entity to the data store, invoke the flush method of the EntityManager instance.

What can we do by using @query JPA annotation? ›

We can use the @Query annotation to modify the state of the database by also adding the @Modifying annotation to the repository method.

Which method of JPA EntityManager would you use to force synchronizing the database with the entities of the persistence context? ›

Flushing is the process of synchronizing the state of the persistence context with the underlying database. The EntityManager and the Hibernate Session expose a set of methods, through which the application developer can change the persistent state of an entity.

How do you join two unrelated entities with JPA and Hibernate? ›

Summary. The only way to join two unrelated entities with JPA 2.1 and Hibernate versions older than 5.1, is to create a cross join and reduce the cartesian product in the WHERE statement. This is harder to read and does not support outer joins. Hibernate 5.1 introduced explicit joins on unrelated entities.

Can we use spring data JPA and Hibernate together? ›

With Spring Data, you may use Hibernate, Eclipse Link, or any other JPA provider. A very interesting benefit is that you can control transaction boundaries declaratively using the @Transactional annotation.

Which dependency should be included to use spring and Hibernate with JPA for database access? ›

Maven Dependencies

This dependency includes JPA API, JPA Implementation, JDBC, and the other necessary libraries. Since the default JPA implementation is Hibernate, this dependency is actually enough to bring it in as well. We can now access the H2 console on localhost http://localhost:8080/h2-console/.

Is JPA still relevant? ›

There are a lot of use cases that can be better implemented with other frameworks. But in my experience, JPA and Hibernate are still a good fit for most applications because they make it very easy to implement CRUD operations. The persistence tier of most applications is not that complex.

What can I use instead of JPA? ›

JPA alternatives

If JPA and Hibernate are not a good fit for your use case, you can use any of the following frameworks: MyBatis, which is a very lightweight SQL query mapper framework. QueryDSL, which allows you to build SQL, JPA, Lucene, and MongoDB queries dynamically.

Can I use JPA without Hibernate? ›

you can't use JPA on its own. JPA is a specification, which defines an API for object-relational mappings and for managing persistent objects and you need a JPA provider to implement it, like Hibernate, EclipseLink. Save this answer.

What can I use instead of Hibernate? ›

Top 10 Alternatives to Hibernate
  • Apache OFBiz.
  • JHipster.
  • Jmix.
  • Spring Framework.
  • Spark.
  • Eclipse Jetty.
  • Apache Flink.
  • Apache Jena.

Why use Mybatis over Hibernate? ›

MyBatis is great for fetch queries (case 2) where you just want an answer. Hibernate would attempt to load the entire object graph, and you'd need to start tuning queries with lazy loading tricks to keep it working on a large domain.

What is the difference between Hibernate and JPA repository? ›

JPA is a specification and defines the way to manage relational database data using java objects. Hibernate is an implementation of JPA. It is an ORM tool to persist java objects into the relational databases.

Do big companies use Hibernate? ›

Hibernate is most often used by companies with >10000 employees and >1000M dollars in revenue. Our data for Hibernate usage goes back as far as 1 years and 8 months. If you're interested in the companies that use Hibernate, you may want to check out ASP.NET and Ruby on Rails as well.

Which is faster JPA or JDBC? ›

It shows that JPA queries are 15% faster than their equivalent JDBC queries. Also, JPA criteria queries are as fast as JPQL queries, and JPA native queries have the same efficiency as JPQL queries.
Query TypesTime in seconds
JPA Criteria Queries53
JPA Native Queries53
JDBC Queries62
1 more row
Aug 2, 2010

Which is better JPA or JDBC? ›

The main advantage of JPA over JDBC for developers is that they can code their Java applications using object-oriented principles and best practices without having to worry about database semantics.

How do I master JPA? ›

JPA and Hibernate in Depth
  1. Introduction to JPA and Hibernate in Depth.
  2. Step 01 - Create a JPA Project with H2 and Spring Boot. ...
  3. COURSE UPDATE : H2 Database URL. ...
  4. Step 02 - Create JPA Entity Course. ...
  5. Step 03 - Create findById using JPA Entity Manager. ...
  6. Step 04 - Configuring to enable H2 console and logging.

Is JPA buddy good? ›

JPA Buddy is a perfect tool for anyone working on data-centric applications. In fact, you can develop an entire CRUD application or a simple microservice by spending nearly zero time writing boilerplate code! Thanks to the JPA Buddy team for the great tool that makes Hibernate even closer to developers.

Does singleton allow lazy initialization? ›

Singleton Class in Java using Lazy Loading

The instance could be initialized only when the Singleton Class is used for the first time. Doing so creates the instance of the Singleton class in the JVM Java Virtual Machine during the execution of the method, which gives access to the instance, for the first time.

How is lazy initialization implemented? ›

Implementing a Lazy-Initialized Property

To implement a public property by using lazy initialization, define the backing field of the property as a Lazy<T>, and return the Value property from the get accessor of the property. The Value property is read-only; therefore, the property that exposes it has no set accessor.

Is lazy initialization good practice? ›

Lazy initialization is an excellent performance optimization technique, allowing you to defer the initialization of objects that consume significant CPU and memory resources until you absolutely need them. Take advantage of lazy initialization to improve the performance of your apps.

What is the difference between lazy initialization and eager initialization? ›

Lazy Loading vs. Eager Loading. While lazy loading delays the initialization of a resource, eager loading initializes or loads a resource as soon as the code is executed.

What is lazy initialization in Singleton pattern? ›

One of the use cases for the Singleton pattern is lazy instantiation. For example, in the case of module imports, we may accidently create an object even when it's not needed. Lazy instantiation makes sure that the object gets created when it's actually needed.

How do you implement lazy initialization in Spring? ›

Setting the property value to true means that all the beans in the application will use lazy initialization. This configuration affects all the beans in the context. So, if we want to configure lazy initialization for a specific bean, we can do it through the @Lazy approach.

How do I fix failed to lazily initialize a collection of role? ›

There are two solutions.
  1. Don't use lazy load. Set lazy=false in XML or Set @OneToMany(fetch = FetchType. EAGER) In annotation.
  2. Use lazy load. Set lazy=true in XML or Set @OneToMany(fetch = FetchType. LAZY) In annotation. and add OpenSessionInViewFilter filter in your web.xml.

How is lazy initialization implemented in Java? ›

Explanation: In the code, the getCarByTypeName() method does the lazy initialization of the map field.
Lazy Initialization
  1. // A Java program that shows the.
  2. // Lazy Initialization.
  3. // import statements.
  4. import java.util.Map;
  5. import java.util.HashMap;
  6. import java.util.Map.Entry;
  7. enum CarsType.
  8. {

How does lazy initialization work in Java? ›

In computer programming, lazy initialization is the tactic of delaying the creation of an object, the calculation of a value, or some other expensive process until the first time it is needed. It is a kind of lazy evaluation that refers specifically to the instantiation of objects or other resources.

What does @lazy do in spring boot? ›

Annotation Interface Lazy

Indicates whether a bean is to be lazily initialized. May be used on any class directly or indirectly annotated with @Component or on methods annotated with @Bean . If this annotation is not present on a @Component or @Bean definition, eager initialization will occur.

What are the disadvantages of lazy initialization? ›

The main disadvantage of lazy initialization is the time penalty associated with each access of the variable caused by the #isNil test. Another disadvantage is that the initialization code is spread around the class and occurs at an unspecified time. On occasion, this can lead to confusion.

What is lazy initialization exception in Hibernate? ›

Class LazyInitializationException

Indicates an attempt to access not-yet-fetched data outside of a session context. For example, when an uninitialized proxy or collection is accessed after the session was closed.

What is the difference between fetch type eager and lazy? ›

FetchType. LAZY = This does not load the relationships unless you invoke it via the getter method. FetchType. EAGER = This loads all the relationships.

What does lazy initialization mean in Hibernate? ›

LazyInitializer is a Hibernate component that helps to generate proxy objects for Entities and can also be used to fetch the underlying entities of these proxy objects.

Which design pattern can be used to implement lazy loading? ›

There are four common ways of implementing the lazy load design pattern: lazy initialization; a virtual proxy; a ghost, and a value holder.

Is lazy loading enabled by default in Entity Framework Core? ›

The advice is not to use lazy loading unless you are certain that it is the better solution. This is why (unlike in previous versions of EF) lazy loading is not enabled by default in Entity Framework Core.


1. Hibernate Tip: How to initialize lazy relationships within a query
(Thorben Janssen)
2. Vlad Mihalcea - High-Performance Hibernate
(Voxxed Days Romania)
3. How to Fix Lombok @ToString Causing LazyInitializationException in Hibernate | JPA Buddy
(JPA Buddy)
4. High-Performance Hibernate - Vlad Mihalcea
(Christian Damsgaard)
5. JPA: How & When to use getReference() Method
(Thorben Janssen)
6. JDK IO 2018 - Vlad Mihalcea - High-Performance Hibernate
(Christian Damsgaard)


Top Articles
Latest Posts
Article information

Author: Greg Kuvalis

Last Updated: 10/03/2023

Views: 5949

Rating: 4.4 / 5 (75 voted)

Reviews: 90% of readers found this page helpful

Author information

Name: Greg Kuvalis

Birthday: 1996-12-20

Address: 53157 Trantow Inlet, Townemouth, FL 92564-0267

Phone: +68218650356656

Job: IT Representative

Hobby: Knitting, Amateur radio, Skiing, Running, Mountain biking, Slacklining, Electronics

Introduction: My name is Greg Kuvalis, I am a witty, spotless, beautiful, charming, delightful, thankful, beautiful person who loves writing and wants to share my knowledge and understanding with you.