java/Spring Hibernate not updating entities

There are three main types of entity objects with JPA:

1. Managed. These are the objects that are cached by JPA-provider, so the JPA-provider keeps track of their states, and commits any changes made to them when the transaction commits. These are the objects you get when you query. They have a database id.
2. New. These are entity objects that are not yet persisted in the database. The JPA-provider knows nothing about them. They do not have a database id.
3. Detached. These are objects that used to be managed, but no longer are. Typically, objects that are returned to a method that is outside the transaction. These object have a database id, but they are not part of the cache, so the JPA-provider does not know them.

In order to persist a relationship between an entity and another, the referenced entity has to managed. There are multiple ways of achieving this.

1. Cascade. Cascade from entity A to entity B means that when a cascading operation is performed on entity A by you in your code, the JPA-provider will perform the same operation on entity B. If you add CascadeType.MERGE to the relationship, and have entity A reference a detached entity B, then doing a merge() on entity A will first to a merge() on entity B, making it managed. When entity A is then stored, it has a reference to a managed B, and the relationship is persisted. (If you also want to persist references to objects that are not already in the database, add CascadeType.PERSIST as well.)
2. Making sure you only reference managed objects. Inside your transaction, load the referenced objects (the managed ones) and replace the references with managed objects, before storing.
3. Widen your transaction. That way, the referenced objects will never become detached.

It could be the case that you need to have "cascade = {CascadeType.MERGE, CascadeType.PERSIST}" on the ManyToOne annotation. The default behavior does not cascade anything to the associated objects.

 /** * (Optional) The operations that must be cascaded to * the target of the association. * * <p> By default no operations are cascaded. */ CascadeType[] cascade() default {}; 

Eg.

@ManyToOne(optional = true, cascade = {CascadeType.MERGE, CascadeType.PERSIST}, fetch = EAGER) 

UPDATE: In case you are using spring managed transaction manager and have the liberty to use annotation driven transaction demarcation, you can try the spring @Transactional annotation instead of manually starting transaction and committing/flushing.

I have following setup:

<bean class="org.springframework.orm.jpa.JpaTransactionManager" id="transactionManager"> <property name="entityManagerFactory" ref="entityManagerFactory"/> </bean> <tx:annotation-driven transaction-manager="transactionManager"/> <bean class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean" id="entityManagerFactory"> <property name="persistenceUnitName" value="persistenceUnit"/> <property name="dataSource" ref="local-dataSource"/> <property name="packagesToScan" value="X"/> <property name="persistenceXmlLocation" value="classpath:persistence.xml"/> </bean> 

DAO class:

@Repository public class EventRepository { @PersistenceContext EntityManager entityManager; @Transactional public void persist(Event event) { entityManager.persist(event); } } 

First of all, make sure that you use the fitting CascadeType on those ManyToOne annotations.

Secondly, a merge Operation in the entityManager/session does not remain object equality by reference. That means, in an update case where a merge is performed, check if a different object is returned. You are supposed to always use the return values of save operations.