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.

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

Look at this Spring service. Eight lines, nothing exotic, no annotations missing as far as a junior reviewer can tell. Before reading on, predict what happens when something calls markActive(42) against a real database.

@Service
public class UserService {
    private final UserRepository userRepo;
    public UserService(UserRepository r) { this.userRepo = r; }

    public User markActive(Long id) {
        User u = userRepo.findById(id).orElseThrow();
        u.setStatus("ACTIVE");
        return u;
    }
}

If you said “an UPDATE statement fires”, you would be wrong. There is no @Transactional on the method, so Spring Data opens a session for the duration of findById, returns the entity, and closes the session. By the time u.setStatus("ACTIVE") runs, u is no longer managed. The mutation exists only in JVM memory. There is no flush, no dirty check, no UPDATE.

This is the kind of bug you can stare at for an hour, because the code is almost right. It would be right if Hibernate worked the way most people imagine it does. The actual mechanics are stranger and more interesting — and once you see them, a long list of mysterious behaviours suddenly make sense: phantom UPDATEs, missing UPDATEs, NonUniqueObjectException, LazyInitializationException, the JPQL query that fires SQL you didn’t expect.

This post is a deep-dive on the persistence context: the in-memory state machine that decides what gets written, when, and why.

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

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.

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

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)

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