Why are some modifications to object lost when I merge that object in Hibernate?

Question

Here are the relevant pieces of the code I inherited. The object "process" is the old process that is passed to the method. The object "newProcess" is what I am replacing it with, using different fields of the user's choosing.

try
{
   final EntityManager em = getEntityManager();
   em.getTransaction().begin();
   JpaProcessDAO pDao = new JpaProcessDAO(em);
   Process newProcess = pDao.findById(processId);

    newProcess.setName(process.getName());
    newProcess.setDataBaseVersion(process.getDataBaseVersion());
    newProcess.setNotes(process.getNotes());
    newProcess.setReadyForUse(process.getReadyForUse();
    newProcess.setSteps(process.getSteps());
    em.merge(newProcess);   <---- WHERE PROBLEM OCCURS
    em.persist(newProcess);
    em.getTrasaction().commit();
}

RESULT: Every field that I change is changed in newProcess EXCEPT "Steps". During the merge step in the code, that list goes back to whatever the steps were in the original object "process".

Now this could be because that "Step" is an object itself, not a primitive like all of the other fields I set in "newProcess":

Mapping in Process.java

@OneToMany(mappedBy="process")
private List<Step>
// getter, setter

In Step.java there is a collection of objects, some of which are lists of nonprimitive objects themselves.

Step.java

public class Step implements Serializable {
    @Id
    @Column(name = "step_id")
    @GeneratedValue(strategy=GenerationType.IDENTITY)
    private int stepId;

    private String duration;
    private String name;
    private String notes;
    private Integer sort;

    @OneToMany(mappedBy="step", cascade=CascadeType.REMOVE)
    private List<Constituent> constituents;

    @OneToMany(mappedBy="step")
    private List<Reference> references;

    @ManyToOne
    @JoinColumn(name ="process_id")
    private Process process;

    @OneToMany(mappedBy="step",cascade=CascadeType.REMOVE)
    private List<StepEquipment> stepEquipments;

    public Step() {
    }

    // getters/setters
}

Does anybody know what this inherited code I have could possibly do wrong?

---

ADDITIONS TO CODE ON 11/29:

public T findById(final Integer id) throws CPDPersistenceExceptin {
   return findByPrimaryKey(id,templateClass);
}

public T findBYPrimaryKey(Object key, Class<T> clazz)  {
   T t = getEntityManager().find(clazz,key);
   getEntityManager.merge(t);
   getEntityManager.refresh(t);
   return t; <--------------  newProcess is returned by this statement.
}

newProcess does not have the steps that were in the original process,nor does it have the ProcessCategories that were in process. The Hibernate logs say that select is going on for process_id, database_version, process_name, process_notes, and process_ready_to_use only in the merge and refresh statements.

Answer 1

You need to synchronize both sides of the association. In your code you're only setting newProcess.setSteps(...), but each Step doesn't set a Process. From here:

However, we still need to have both sides in sync as otherwise, we break the Domain Model relationship consistency, and the entity state transitions are not guaranteed to work unless both sides are properly synchronized.

So in other words, you would need to do something along the lines of:

newProcess.setSteps(process.getSteps());
process.getSteps().forEach(s -> s.setProcess(newProcess));

Answer 2

As in answer from dyslexit told you need to set the Process to each Step.

But in addition you need to have the new Steps persisted and old ones removed. You can do this manually per Step but easier way would be to alter your code a bit.

Mofify the mapping annotation in step like:

@OneToMany(mappedBy = "process", cascade=CascadeType.PERSIST, orphanRemoval=true)
private List<Step> steps;

so tell persist to cascade to Steps also and to remove all Steps that are detached from Process.

Modify the update logic:

// newProcess.setSteps(process.getSteps());
// em.merge(newProcess);   <---- WHERE PROBLEM OCCURS
// em.persist(newProcess);

newProcess.getSteps().clear(); // remove old steps
newProcess.getSteps().addAll(process.getSteps()); // add new steps
// You need to set the other side of association also as below
newProcess.getSteps().forEach(s -> s.setProcess(newProcess));
// em.persist(newProcess); // not sure if needed

SO: do not REPLACE the list but instead MODIFY the original list.

ALSO: there might not be a need for any merge/persist operation (and certainly doing both in series is not something that should ever be done). But because you use mystical JpaProcessDAO I can not be sure so check that.

And also see for what those are really used, great explanation here.

I am guessing that entity manager might handle everything just fine - without persist/merge stuff -because I think you already got managed entity when called pDao.findById(processId);, that is why I have commented it out.

Another story is then the mappings you have in your Step class. Those might also need changes to persistence & cascade setting.

As a side note: have also a look at this question how you might have update done easier with ModelMapper.