merging a detached or new entity with an existing entity in hibernate/jpa best practice question

Question

When the business layer creates a new entity, which logically represents an instance of an existing entity that should be updated (say they share the same business key), is this method of merging bad practice?

public User add(User user){

    User existingUser = getUserDao().findByBusinessKey(user.getBusinessKey(), false);
    user.setId(existingUser.getId());

    user = getUserDao().merge(user);

    return user;
}

I ask because setting the ID explicitly on the detached entity feels pretty strange to me, but even though the equals and hashcode method of the User entity are appropriately implemented, setting the ID here is the only way to ensure the merge takes place.

Is there a better practice?

Are there specific drawbacks to this method that would bite me later on?

Thanks for taking a look!

Answer 1

That code will work, but setting the ID explicitly on the detached entity should not be necessary. A typical Hibernate app have a 'save' method that handles two cases:

1. The user wanted to create a new User, so the app creates a User object with 'null' as the ID.
2. The user queried for a list of users, and is selecting one for edit. In this case the app does a query and propagates the object to the 'save' method. The object will have an ID and the code will apply new values to it.

Looks like something in your code isn't doing the second case in the typical way. If the 'user' object comes from some prior Hibernate query (triggered by the user clicking 'edit user' or something like that), then it will already have an ID. Thus, only the merge(user) call is needed.

I usually do something like this:

if (user.getId() == null)
  em.persist(user);
else
  user = em.merge(user);

Then I add code to handle optimistic locking issues (another session updated the object) and unique constraint issues (another session tried to persist something with the same business key).

Frameworks such as Seam can make this even simpler because they propagate the Hibernate session between the controller bean methods. So even the 'merge' is not needed.