Difference between Hibernate update by Session.update and HibernateTemplate.merge

I saw to types of update开发者_开发知识库 operation: First:

    getHibernateTemplate().execute(new HibernateCallback() {
        public Object doInHibernate(Session session) {  
            session.flush();
            session.setCacheMode(CacheMode.IGNORE);
            SomeObject ss = (SomeObject) session.get(SomeObject.class, id);
            long next = ss.getAndIncrement();
            session.update(ss);
            session.flush();
            return null;
        }
    });

and secondly

    SomeObject ss = loadSomeObject(); 
    long next = ss.getAndIncrement();
    getHibernateTemplate.merge(ss);

These two method do the same. I want to know which one is better and safe and why. Thank you.

In the first operation the object ss is attached to the session. where as in the second operation its detached. So if you have an attached objects you can use update. If you have a detached objects then use merge which first attaches the object to the session then will do an update.

EDIT: For your information on attached(persistent) and detached objects :

Hibernate defines and supports the following object states:

Transient - an object is transient if it has just been instantiated using the new operator, and it is not associated with a Hibernate Session. It has no persistent representation in the database and no identifier value has been assigned. Transient instances will be destroyed by the garbage collector if the application does not hold a reference anymore. Use the Hibernate Session to make an object persistent (and let Hibernate take care of the SQL statements that need to be executed for this transition).

Persistent - a persistent instance has a representation in the database and an identifier value. It might just have been saved or loaded, however, it is by definition in the scope of a Session. Hibernate will detect any changes made to an object in persistent state and synchronize the state with the database when the unit of work completes. Developers do not execute manual UPDATE statements, or DELETE statements when an object should be made transient.

Detached - a detached instance is an object that has been persistent, but its Session has been closed. The reference to the object is still valid, of course, and the detached instance might even be modified in this state. A detached instance can be reattached to a new Session at a later point in time, making it (and all the modifications) persistent again. This feature enables a programming model for long running units of work that require user think-time. We call them application transactions, i.e., a unit of work from the point of view of the user.

Whats an API without any code examples?

SessionFactory sf =         ctx.getBean("hibernateSessionFactory",SessionFactory.class);
Session session = sf.openSession();
Transaction t = session.beginTransaction();
try {
   Session s2 = sf.openSession();
    Organization org = (Organization)s2.get(Organization.class,100624l);//1
    org.setOrgName("org");
    s2.close();//2
   Organization org1 =  (Organization)session.get(Organization.class,100624l);//3
    org.setOrgName("testOrg");
   org1.setOrgName("org");//a
    session.merge(org);//4
    System.out.println(org == org1);//b 
     t.commit();
} catch (HibernateException e) {
  t.rollback();
  throw e;
}finally{
      session.close();
 }

1. 1st instance is loaded and made persistent.
2. The instance is detached.
3. Another instance is loaded
4. At the point of executing this operation, there are 2 instances of the same object in the session(org and org1) – org is detached and org1 is persistent If we do an update() or saveOrUpdate() there, we get the below exception:

org.hibernate.NonUniqueObjectException: a different object with the same identifier value was already associated with the session: [com.spring.model.Organization#100624]

a. We do a merge here which:

I. Merges the state of the detached object + persistent object.

II. In case of conflict, the object which is merged wins, like in this case, the value saved will be : testOrg

III. Had we merged on org1, we would have got org.

b. This will always return false, meaning post merge, org was still in DETACHED state

I hope the diff. is clear now.

Summary : saveOrUpdate() or update() will throw an exception if there are 2 instances of the same object in the session(one detached and one persistent)

merge() will not throw the exception, but will save the object while merging the changes.

Merge Does Following

Merge has intelligence. It has lot of pre-checks before it go actual merge(if required)

1. if Object is transient, It simply fires INSERT query makes object persistent(attached to session)
2. if Object is detached, fires select query to check whether data modified or not if modified, fires UPDATE query otherwise just ignore merge task.

where as session.update

1. throws exception if object is transient.
2. if Object is detached, it simply fires UPDATE query irrespective of data changes to object.

session.merge is expensive than update

The basic difference is:

Merge() is not concerned about sessions whether persistent or detached...it will just update without considering the sessions.

In case of update() it will throw an exception like org.hibernate.NonUniqueObjectException: a different object with the same identifier value was already associated with the session.

It's explained here with a good example:

http://www.java4developer.com/difference-between-update-and-merge-in-hibernate/

Both update() and merge() methods in hibernate are used to convert the object which is in detached state into persistence state. But there is little difference. Let us see which method will be used in what situation. Let Us Take An Example

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

Employee s1 = null;
Object o = session1.get(Employee.class, new Integer(101));
s1 = (Student)o;
session1.close();

s1.setSSN(97);

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

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

Employee s1 = null;
Object o = session1.get(Employee.class, new Integer(101));
s1 = (Employee)o;
session1.close();

s1.setMarks(97);

Session session2 = factory.openSession();
Employee s2 = null;
Object o1 = session2.get(Employee.class, new Integer(101));
s2 = (Employee)o1;
Transaction tx=session2.beginTransaction();

session2.merge(s1);

Hope you are clear…, actually update and merge methods will come into picture when ever we loaded the same object again and again into the database, like above.