Differences among save, update, saveOrUpdate, merge methods in Session?

You have most things right, but update works a little differently from how you were describing it. If an object is in the session (i.e. persistant), update is completely unnecessary. Hibernate handles persisting any changes to objects in the session when the session is flushed. Calling update on them will do nothing (and may incur a performance penalty; I'm not sure).

Update is designed to be called on detached objects, i.e. those that are now outside the session they were loaded in. @hvgotcodes explanation seems to be incorrect, because update should only be called if the object is not in the session. update can fail if an instance of the object is already in the session. Merge should be used in that case. It merges the changes of the detached object with an object in the session, if it exists. If there's no object in the session, it will create a new one.

So often you can avoid calling update/merge at all, but if you end up having to call one, merge handles a broader range of situations. My understanding is the only reason to use update is for better performance, assuming you know it won't error.

This thread has a pretty good summary of some other hibernate methods, as well.

Edit: I just thought I should say there are more differences between merge and update than I originally said. Update modifies the given entity to be persistent, whereas merge returns a new persistent entity. For merge, you're supposed to throw away the old object. Another difference is merge does a dirty check by selecting from the DB before deciding whether to write its data, whereas update always persists its data to the DB whether it's dirty or not.

There are probably other small differences. It's always good to test Hibernate behavior out by logging the generated SQL, because the behavior doesn't always match the docs, at least in my experience.

You are exactly right in all of your assessments. You get it.

For your first question, if i recall correctly, save specifically does an insert. So calling save again will result in another row in the db.

For your second question, update updates an object in the session. So if the object is in the session it will update. If the object is not in the session, you should call merge. I believe calling update for a detached instance will result in an exception.

@Naliba has given excellent answer over Update() method.

Hibernate life cycle in the following image helps get an idea above the methods.

Example: Let us see merge() method situation.

SessionFactory factory = cfg.buildSessionFactory();
Session session1 = factory.openSession();

Student student1 = null;
Object object1 = session1.get(Student.class, new Integer(101));
student1 = (Student)object1;
session1.close();

student1.setMarks(97);// -->object will be in some RAM location, not in the session1 cache

Session session2 = factory.openSession();
Student student2 = null;
Object object2 = session2.get(Student.class, new Integer(101));
student2 = (Student)object2;
Transaction tx=session2.beginTransaction();

session2.merge(student1);

Above student1 is in detached state, modified that detached object student1, now if we call update() method then hibernate will throws an error.

In this session2, we called session2.merge(s1); now into student2 object student1 changes will be merged and saved into the database.

session.update() - It is used for a scenario when you have load an object Person1 from hibernate session. Now it is being used in application - may be on client side also, has been updated. We want to save it again. We know that no change has been done in Person object in data base. So we can simply use update.

session.merge() - In above scenario, if changes have been done in person data before saving the changed Person1 object, then we should use merge. It will merge the changes.

session.save() - It can be used to save a new object. It returns the serialiable identity.

session.persist() - It is same as save(), but is void method and does not return anything.

session.saveOrUpdate() - This method will work for both new and old objects. If object is new, it will work like simple save or if object is already persistent, it will work like update.

session.lock() - It is used only to take the lock on object or you can say to check the version of object. It is not meant for updating the object. It should be used to reattach the object, only if you are sure that object state is not changed in database already. Otherwise, it may override the changes. < Inviting more points on this.