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

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 https://t.co/kWpi3etBAZ pic.twitter.com/sVqeMgFSLu

— Java (@java)December 6, 2018

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

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) { this.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) { this.id = id; return that; } public String getReview() { return review; } public PostComment setReview(String review) { this.review = review; return that; } public post getPost() { return post; } public PostComment setPost(Post Post) { this.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:

LOGGER.info("Clear second level cache");entityManager.getEntityManagerFactory().getCache().evictAll();LOGGER.info("Load post comment");Post comment comment = entityManager.find( PostComment. class, 1L );assertEquals("Must read!", comment.getReview());Post Post = comment.getPost();LOGGER.info("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: com.vladmihalcea.book.hpjp.hibernate.fetching.HibernateInitializeTest$Post -- Remove entity cache: com.vladmihalcea.book.hpjp.hibernate .fetching.HibernateInitializeTest$PostComment -- Fetch of a PostCommentSELECT pc.id AS id1_1_0_, pc.post_id AS post_id3_1_0_, pc.review AS review2_1_0_FROM post_comment pcWHERE pc.id=1-- Post entity class: com.vladmihalcea.book.hpjp .hibernate.fetching.HibernateInitializeTest$Post $HibernateProxy $5 LVxadxFSELECT p.id LIKE id1_0_0_, p.title LIKE title2_0_0_FROM post pWHERE p.id=1

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.

LOGGER.info("Clear second level cache");entityManager.getEntityManagerFactory().getCache().evictAll();LOGGER.info("Load post comment");post comment comment = entityManager.createQuery( "select pc " + "from PostComment pc" + "join fetch pc.post" + "where pc.id = :id", PostComment.class).setParameter("id", 1L).getSingleResult();assertEquals(" A must be read !", comment.getReview());Post Post = comment.getPost();LOGGER.info("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: com.vladmihalcea.book.hpjp.hibernate.fetching.HibernateInitializeTest$Post -- Remove entity cache: com.vladmihalcea.book.hpjp.hibernate .fetching.HibernateInitializeTest$PostComment -- Fetch of a PostCommentSELECT pc.id AS id1_1_0_, p.id AS id1_0_1_, pc.post_id AS post_id3_1_0_, pc.review AS review2_1_0_, p.title AS title2_0_1_FROM post_comment pcINNER JOIN post p id= ON pc p.idWHERE pc.id =1- - Post entity class: com.vladmihalcea.book.hpjp.hibernate.fetching.HibernateInitializeTest$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:

LOGGER.info("Loading a PostComment");Comment PostComment = entityManager.find( PostComment.class, 1L);assertEquals("A must read!", comment.getReview());Post post = comment.getPost(); LOGGER.info("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 = `com.vladmihalcea.book.hpjp.hibernate.fetching.HibernateInitializeTest$PostComment`, key = `com.vladmihalcea.book.hpjp.hibernate.fetching.HibernateInitializeTest$PostComment# 1 `-- Proxy-Klasse: com.vladmihalcea.book.hpjp.hibernate.fetching.HibernateInitializeTest$Post$HibernateProxy$rnxGtvMK-- Cache-Treffer: region = `com.vladmihalcea.book.hpjp.hibernate.fetching.HibernateInitializeTest$ Post`, clave = `com.vladmihalcea.book.hpjp.hibernate.fetching.HibernateInitializeTest$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:

LOGGER.info("Loading a post");Post Post = entityManager.find(Post.class, 1L);List<PostComment> comments = post.getComments();LOGGER.info("Collection of classes: {}", Comments .getClass().getName());Hibernate.initialize(Comments);LOGGER.info("Post comments: {}", Comments);

Hibernate runs a SQL query to load itpost commentCollection:

-- Laden eines Posts: Cache-Match: region = `com.vladmihalcea.book.hpjp.hibernate.fetching.HibernateInitializeTest$Post`, key = `com.vladmihalcea.book.hpjp.hibernate.fetching.HibernateInitializeTest$Post#1 ` -- Sammlungsklasse: org.hibernate.collection.internal.PersistentBag- Cachetreffer, aber Element kann nicht gelesen werden/ist ungültig: region = `com.vladmihalcea.book.hpjp.hibernate.fetching.HibernateInitializeTest$ Post.comments`, key = `com.vladmihalcea.book.hpjp.hibernate.fetching.HibernateInitializeTest$Post.comments#1`SELECT pc.post_id AS post_id3_1_0_, pc.id AS id1_1_0_, pc.id AS id1_1_1_, pc.post_id LIKE post_id3_1_1_, pc.review 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 = `com.vladmihalcea.book.hpjp.hibernate.fetching.HibernateInitializeTest$Post`, key = `com.vladmihalcea.book.hpjp.hibernate.fetching.HibernateInitializeTest$Post#1 ` – Sammlungsklasse: org.hibernate.collection.internal.PersistentBag – Cache-Treffer: region = `com.vladmihalcea.book.hpjp.hibernate.fetching.HibernateInitializeTest$Post.comments`, key = `com.vladmihalcea .book . hpjp.hibernate.fetching.HibernateInitializeTest$Post.comments#1`-- Cache-Match: region = `com.vladmihalcea.book.hpjp.hibernate.fetching.HibernateInitializeTest$PostComment`, key = `com.vladmihalcea.book.hpjp . hibernate.fetching.HibernateInitializeTest$PostComment#1`-- Cache-Match: region = `com.vladmihalcea.book.hpjp.hibernate.fetching.HibernateInitializeTest$PostComment`, key = `com.vladmihalcea.book.hpjp .hibernate.fetching . HibernateInitializeTest$PostComment#2`-- Cache-Übereinstimmung: region = `com.vladmihalcea.book.hpjp. hibernate.fetching.HibernateInitializeTest$PostComment`, key = `com.vladm ihalcea.book.hpjp.hibernate.fetching.HibernateInitializeTest$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

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.

Related