JPA Archives - Page 5 of 5

Ankur in Hibernate

find() vs getReference() in Hibernate 7: A Decision Matrix (and Why get()/load() Belong in the Same Conversation)

Read this code and predict whether it sends a SELECT to the database: @Transactional public void assignCategory(Long productId, Long categoryId) { Category category = em.getReference(Category.class, categoryId); Product product = em.find(Product.class, productId); product.setCategory(category); } If you said "two SELECTs" — one for each line — you would be half wrong. find() on Product does hit the database. getReference() on Category does not, unless categoryId is already in the first-level cache. The UPDATE to write category_id to the product row happens at flush; the category column only needs the ID, which the proxy already holds. That single avoided SELECT matters in bulk operations. It is also one of the most consistently misunderstood distinctions in Hibernate. This post is a decision guide: six scenarios, each with the right call and the reasoning.

Ankur in Hibernate

@PrePersist and Friends: Five Lifecycle Callback Bugs You’ll Ship If You’re Not Careful

We had a callback that "audited every save" — except it silently skipped about half of them. The @PreUpdate on the AuditListener ran correctly for every web-layer save. It never ran for the nightly batch job. The batch used HQL bulk updates. Nobody remembered that bulk operations bypass the persistence context entirely, so lifecycle callbacks never fire for them. The audit log looked complete. It was missing six months of batch changes. That is bug four in this list. Here are all five, each one a real failure mode with the code that produces it and the fix. Technical Note: JPA vs. Hibernate Behavior It is important to distinguish that all annotations discussed in this guide (like @PrePersist, @PostUpdate, etc.) are defined by the Jakarta Persistence API (JPA) specification. Hibernate 7 serves as the implementation provider. While the API is standard, specific behaviors such as dirty checking algorithms, the exact timing of the flush, and session state transitions are governed by Hibernate-specific logic. The Problem: Fragmented Business Logic In many legacy applications, developers scatter logic like password encryption, audit logging, and data normalization across various controllers and services.

Ankur in Hibernate

The Hibernate 7 Persistence Context: How Hibernate Tracks Your Entities (and Where It Gets Surprising)

Look at this Spring service. Eight lines, nothing exotic, no annotations missing as far as a junior reviewer can tell. Predict — before reading on — what happens when something calls markActive(42) against a real database. If you said "an UPDATE statement", you would be wrong. The actual mechanics are stranger and more interesting — and once you see them, a long list of mysterious behaviours suddenly make sense.

Ankur in Hibernate

Bootstrapping EntityManager in Hibernate 7 (Jakarta Persistence 3.2) – XML vs Programmatic Guide

Are you struggling to bridge the gap between your Java objects and your relational database in the modern Jakarta EE era? If you’ve ever felt buried under boilerplate JDBC code or confused by the transition to Hibernate 7, you aren't alone. In modern Java development, bootstrapping EntityManager in Hibernate 7 is the foundational step for any robust data persistence layer. Hibernate 7 has fully embraced Jakarta Persistence 3.2, bringing stricter standards, better performance, and a move toward Java 17+ features. This version marks a significant milestone in the decoupling of Hibernate-specific logic from standard JPA interfaces. TL;DR 🚀 Requirements: Java 17+ and Jakarta Persistence 3.2 (complete jakarta.* namespace transition). 🏗️ Architecture: EntityManagerFactory (EMF) is a thread-safe singleton; EntityManager (EM) is for short-lived units of work. ⚙️ Configuration: Use XML (persistence.xml) for stability; use Programmatic (PersistenceConfiguration) for cloud-native/dynamic environments. ⚠️ Critical Warning: Never create a new EntityManagerFactory per request. It leads to catastrophic Metaspace OOM errors. The Problem: The Complexity of Manual Data Handling Managing database connections manually is a developer's nightmare. From opening connections and handling SQL exceptions to mapping result sets back into Java objects, the "traditional" JDBC way is error-prone and tedious. Without a properly bootstrapped EntityManager, your application lacks a unified way to manage entity lifecycles, leading to: Memory Leaks: Connections that are never returned to the pool. Data Inconsistency: Transactions that aren't properly synchronized across operations. Performance Bottlenecks: The infamous "N+1" query issues that arise when manual fetching isn't optimized.

Ankur in Hibernate

Bootstrapping Hibernate 7: SessionFactory vs EntityManagerFactory vs Spring Boot Auto-Config — A Decision Guide

Most Spring Boot developers would struggle to answer the question: which Hibernate bootstrap path are you actually using? The answer is "the one Spring Boot chose for you", which is the EntityManagerFactory path, built by HibernateJpaAutoConfiguration, wired to a HikariDataSource, reading from application.properties. You have never typed a single line of Hibernate bootstrap code. That is fine for the common case. But when something breaks at startup — the wrong dialect is selected, HikariCP sizing is wrong, the schema validation fails — you need to know what is actually being configured and where. And for projects outside Spring Boot (command-line tools, framework libraries, Jakarta EE deployments), you need to choose a bootstrap path and implement it deliberately. This post covers all three paths, when each makes sense, and the production failure that catches developers who autoconfig their way to production without understanding what they built.

Ankur in Hibernate

Hibernate 7 Hello World: A Working Project from Empty Folder to First Insert

Most Hibernate Hello World tutorials get you to a running INSERT in about 10 minutes. They also leave out three things that will bite you the moment you move past the trivial case. First: the import packages. Hibernate 7 requires jakarta.persistence.*, not javax.persistence.*. Every tutorial written before 2022 uses the old namespace. If you copy the entity annotation from a pre-Hibernate 6 guide, the annotations will not be recognised and you will spend 30 minutes wondering why your table never appears. Second: the persistence.xml location trap in Maven multi-module setups. The file belongs at src/main/resources/META-INF/persistence.xml in the module that contains your entity classes. Putting it in the wrong module produces a silent failure at bootstrap. Third: the LazyInitializationException you will hit in your second example. The first example always works because you access everything inside one open session. The second example accesses an association after the session closes. This post calls that out explicitly so you see it coming. Everything else is the standard step-by-step: Maven setup, entity, configuration, utility class, first insert. The code is complete and runs without modification on Java 17+. Three Things This Guide Gets Right That Most Hello World Tutorials Skip Hibernate 7 is not just a minor update; it’s optimized for modern environments like Jakarta EE 11 and Java 17/21/25+. It leverages the latest features of the JPA (Jakarta Persistence API) to provide a more type-safe and performant way to interact with your data. High-Level Architecture Overview Understanding the flow of data is crucial for mastering any ORM. Here is the architectural stack for this tutorial: Java Application → Hibernate Session → JPA Entity Manager → Dialect → Database (H2/MySQL)

Ankur in Hibernate

Solved: Bean property ‘configurationClass’ is not writable or has an invalid setter method

Every developer has those moments where a seemingly simple task turns into a head-scratching puzzle. This error, encountered while trying to configure a custom LocalSessionFactoryBean in Spring Boot, is a perfect example of a subtle type mismatch causing a cryptic failure. The Scenario and the Error The goal was to set up a custom SessionFactory bean using Spring's LocalSessionFactoryBean. The initial, problematic configuration was: @Configuration public class HibernateConfig { @Bean public LocalSessionFactoryBean sessionFactory() { LocalSessionFactoryBean sessionFactory = new LocalSessionFactoryBean(); // … set data source, hibernate properties … // This line caused the error! sessionFactory.setConfigurationClass(org.hibernate.cfg.Configuration.class); return sessionFactory; } } This configuration resulted in the following exception upon application startup: org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'sessionFactory': Bean property 'configurationClass' is not writable or has an invalid setter method. Does the parameter type of the setter match the return type of the getter?

Ankur in Hibernate

Solved: java.lang.NoClassDefFoundError: org/hibernate/cache/CacheProvider

Encountering a java.lang.NoClassDefFoundError can be one of the most frustrating issues when working with Java applications. This particular error — org/hibernate/cache/CacheProvider — is a common stumbling block for developers upgrading or mixing Hibernate versions. Let's break down what it means and how to fix it. Understanding the Error The NoClassDefFoundError occurs when the JVM tries to load a class by its fully qualified name but cannot find its definition at runtime — even though the class existed at compile time. In this case, org.hibernate.cache.CacheProvider was the standard interface for Hibernate second-level cache integration in Hibernate 3.x. It was deprecated in Hibernate 4 and completely removed in Hibernate 5+, replaced by org.hibernate.cache.spi.RegionFactory.