✅ Short Answer
You need flush() when you want to force Hibernate to immediately synchronize in-memory changes with the database within an open transaction — usually so that subsequent queries or database operations see the latest changes before you commit.
🔎 Detailed Explanation
By default, Hibernate uses delayed (batched) writes — changes to persistent entities are kept in the session’s in-memory cache (the persistence context) until it decides to flush automatically (usually on transaction commit or before certain queries).
Explicit flush() is useful when:
1️⃣ You need to run a query that depends on the latest changes:
- Without flush: the query might use stale data because changes are only in memory.
- With flush: changes are pushed to the database → your query sees the correct, updated state.
2️⃣ You want to detect database-level constraints or triggers early:
- Flushing runs the SQL now → if you violate a unique constraint or foreign key, you find out immediately, not at commit time.
3️⃣ You want precise control over when SQL hits the database:
- Useful in complex transaction flows where you must ensure certain changes are persisted before moving on.
4️⃣ You’re using FlushMode.MANUAL and need to explicitly synchronize changes.
🧑💻 Example: Query Needing Latest Data
Session session = sessionFactory.openSession();
Transaction tx = session.beginTransaction();
User user = new User();
user.setName("Alice");
session.save(user);
// Without flush: query below might not see Alice if session auto-flush doesn’t trigger
session.flush(); // Forces INSERT of Alice
// Now we can safely run a query relying on Alice being in DB
List<User> result = session.createQuery(
"FROM User WHERE name = 'Alice'", User.class).list();
tx.commit();
session.close();
💡 Extra Insight: When you don’t need explicit flush
- In most CRUD scenarios, auto-flush (FlushMode.AUTO) already synchronizes changes before transaction commit or before executing HQL/Criteria queries.
- Explicit
flush()is an advanced tool — avoid overusing it as it can reduce performance by forcing unnecessary SQL execution.
📌 Key Takeaways
✅ Use flush() when you need immediate consistency between your session’s in-memory changes and the database.
✅ Useful before queries that depend on recent modifications or when you want early constraint validation.
✅ In many cases, Hibernate’s automatic flushing is sufficient — explicit flush() is mostly for special cases.