Скачать или смотреть Solving Hibernate's Unintended Commits: Understanding Flush Modes in JPA

Discover why Hibernate commits changes prematurely during a transaction and how to prevent it by adjusting flush modes.
---
This video is based on the question https://stackoverflow.com/q/76906023/ asked by the user 'Okay Atalay' ( https://stackoverflow.com/u/5193183/ ) and on the answer https://stackoverflow.com/a/76907226/ provided by the user 'Semih Erkaraca' ( https://stackoverflow.com/u/6373062/ ) at 'Stack Overflow' website. Thanks to these great users and Stackexchange community for their contributions.

Visit these links for original content and any more details, such as alternate solutions, latest updates/developments on topic, comments, revision history etc. For example, the original title of the Question was: Hibernate commits the changes when transaction is still open and select query invoked

Also, Content (except music) licensed under CC BY-SA https://meta.stackexchange.com/help/l...
The original Question post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license, and the original Answer post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license.

If anything seems off to you, please feel free to write me at vlogize [AT] gmail [DOT] com.
---
Understanding the Issue with Hibernate Transactions

If you’re working with Hibernate and Spring Data JPA, you may have encountered a perplexing problem: Hibernate committing changes when the transaction is still open and a select query is invoked. This situation can lead to unexpected data changes and inconsistencies in your application. In this guide, we’ll discuss the problem in detail and provide a solution that you can implement swiftly.

The Scenario

In our example scenario, the following sequence of events occurs:

Entity Update: An update operation on a user entity takes place.

Select Query Execution: A select query immediately follows the update within the same transaction.

Unexpected Result: The changes made to the entity are reflected in the database before the transaction is completed.



Analyzing the Provided Code

Let’s break down the sample code to understand the mechanics behind this behavior:

[[See Video to Reveal this Text or Code Snippet]]

Services and Operations

You have the following services calling each other:

Service1 calls Service2.

Service2 calls UserService where the actual update occurs.

Here’s the critical method in UserService:

[[See Video to Reveal this Text or Code Snippet]]

At this point, one might expect the transaction to remain open and any updates not yet committed to the database. But, surprisingly, after executing findByDepartmentGuid, the database reflects the change to "USER1"—even before the transaction has been completed.



Root Cause: Understanding Flush Modes

The crux of the issue lies in Hibernate’s flush modes. Hibernate manages writes to the database with different flush strategies, which can drastically affect behavior during transactions.

The Four Flush Modes

MANUAL (0) - You explicitly tell Hibernate when to flush changes.

COMMIT (5) - Flushing only occurs during transaction commit.

AUTO (10) - Automatic flushing occurs before each query execution.

ALWAYS (20) - Flushes changes before any select query, leading to the issue you faced.

Since you are experiencing this issue, it appears that Hibernate is set to AUTO flush. This mode forces changes to be flushed to the database whenever a select query is executed, causing the unwanted behavior.



Solution: Changing the Flush Mode

To prevent Hibernate from committing changes until the transaction is complete, you should adjust the flush mode to either MANUAL or COMMIT. Let’s do this by modifying your Spring JPA properties.

Configuration Steps

Modify your application properties or YAML file to set the flush mode to COMMIT:

[[See Video to Reveal this Text or Code Snippet]]

This adjustment ensures that changes are not immediately flushed to the database, allowing you to manage when the data is written more effectively and avoid premature commits during ongoing transactions.



Conclusion

By understanding the flush modes in Hibernate, you can tackle issues around unexpected database commits during transactions effectively. The solution outlined above will help in ensuring that updates remain isolated until the transaction is completed. It's a valuable practice to review these configurations to ensure your application behaves as intended.

If you run into this issue again, remember to check your flush mode settings—it can save you a lot of debugging time and preserve the integrity of your data.