Question

I’m gonna go with this design:

create an object and keep it alive during all web-app session.

And I need to synchronize its state with database state.

What I want to achieve is that :

IF between my db operations, that is, modifications that I persist to a db

someone intentionally spoils table rows, then on next saving to a database

all those changes WOULD BE OVERWRITTEN with the object state, that always contains valid data.

What Hibernate methods do you recommend me to use to persist the modifications in a database?

saveOrUpdate() is a possible solution, but maybe there’s anything better?

Again, I repeat how it looks. First I create an object without collections. Persist it (save()).

Then user provides us with additional data. In a serviceLayer, again, we modify our object in memory (say, populate it with collections) and then, persist it again.

So every serviceLayer operation of the next step must simply guarantee that database contains the exact persistent copy of this object that we have in memory. If data in a database differ, it MUST BE OVERRIDDEN with the object (kept in memory) state.

What Session operations do you recommend?

Answer 1

FWIW saveOrUpdate() looks like the best option overall:

The saveOrUpdate() method is in practice more useful than update(),
save(), or lock(): In complex conversations, you don’t know if the item is in
detached state or if it’s new and transient and must be saved. The automatic
state-detection provided by saveOrUpdate() becomes even more useful when you
not only work with single instances, but also want to reattach or persist a network
of connected objects and apply cascading options.

However for your case, if you are sure the entity was modified in detached state, and/or don’t mind occasionally hitting the DB with an unnecessary UPDATE, maybe update() is the safest choice:

The update() operation
on the Session reattaches the detached object to the persistence context and
schedules an SQL UPDATE. Hibernate must assume that the client modified the
object while it was detached. […] The persistence context is flushed automatically
when the second transaction in the conversation commits, and any
modifications to the once detached and now persistent object are synchronized
with the database.

Quotes from Java Persistence with Hibernate, chapter 11.2.2.