Hibernate collection data lost when two transactions save data concurrently - mysql

Question

I'm facing a strange problem of "losing" data when updating data using Hibernate.
The application is deployed on JBoss AS 7, database connection isolation level to MySql DB is set to READ_COMMITED.
I have entities defined via inheritance like this:
#Entity
#Table(name = "element")
#Inheritance(strategy=InheritanceType.JOINED)
public class ElementEntity {
#Id
#GeneratedValue(strategy = GenerationType.AUTO)
#Column(name="i_element", nullable=false)
private Integer iElement;
#Column(name="hash")
private String hash;
...
}
#Entity
#Table(name = "element_a")
#PrimaryKeyJoinColumn(name="i_element")
public class AElementEntity extends ElementEntity {
... // some primitive fields
}
#Entity
#Table(name = "element_b")
#PrimaryKeyJoinColumn(name="i_element")
public class BElementEntity extends ElementEntity {
... // some primitive fields
}
#Entity
#Table(name = "element_c")
#PrimaryKeyJoinColumn(name="i_element")
public class CElementEntity extends ElementEntity {
... // some primitive fields
#OneToMany(mappedBy="cElement", cascade=CascadeType.ALL)
private List<NodeEntity> nodes;
}
#Entity
#Table(name="node")
public class NodeEntity {
#Id
#GeneratedValue(strategy = GenerationType.AUTO)
#Column(name = "i_node")
private Integer iNode;
#ManyToOne
#JoinColumn(name="i_element", referencedColumnName="i_element")
private CElementEntity cElement;
... // some primitive fields
}
and dao implementation like this:
public class ElementDaoImpl implements ElementDao {
private static final Logger logger = Logger.getLogger(ElementDaoImpl.class);
private EntityManager entityManager;
public ElementDaoImpl(EntityManager entityManager) {
super();
}
#Override
public List<ElementEntity> load(String hash) {
// nacist vsechny elementy pro SGL
Query query = entityManager.createQuery("FROM " + ElementEntity.class.getSimpleName() + " WHERE hash = :hash");
query.setParameter("hash", hash);
List<ElementEntity> elements = (List<ElementEntity>) query.getResultList();
//.. log C element
return elements;
}
#Override
public void save(String hash, List<ElementEntity> elements) {
removeElementsByHash(hash);
for (ElementEntity element : elements) {
if (logger.isDebugEnabled()) {
if (element instanceof CElement) {
CElementEntity cElementEntity = (CElementEntity) element;
logger.debug("Storing for hash " + hash + " nodes " + cElementEntity.getNodes());
}
}
entityManager.persist(entity);
entityManager.flush();
}
entityManager.clear();
}
private void removeElementsByHash(String hash) {
Query query = getEntityManager().createQuery("FROM " + ElementEntity.class.getSimpleName() + " WHERE hash = :hash");
query.setParameter("hash", hash);
List<ElementEntity> entities = (List<ElementEntity>) query.getResultList();
if (entities != null && !entities.isEmpty()) {
for (ElementEntity entity : entities) {
entityManager.remove(entity);
}
}
entityManager.flush();
entityManager.clear();
}
}
dao is created in EJB stateless bean:
#Stateless(name=ElementServiceBean.NAME, mappedName=ElementServiceBean.NAME)
#Local({ElementService.class})
#LocalBinding(jndiBinding=ElementServiceBean.NAME)
public class ElementServiceBean implements ElementService {
public static final String NAME = "ElementServiceBean";
#PersistenceContext(unitName = "coredb_em")
protected EntityManager entityManager;
private ElementDao elementDao;
#PostConstruct
public void init() {
this.elementDao = new ElementDaoImpl(entityManager);
}
#Override
public List<ElementEntity> load(String hash) {
return elementDao.load(hash);
}
#Override
public void save(String hash, List<ElementEntity> elements) {
elementDao.save(hash, elements);
}
}
Now, in my app sometimes happens situation when save method is called by two different threads concurrently almost at the same time, which causes that data from the collection in CElementEntity are somehow lost.
I don't use any form of Hibernate locking. No exception is thrown. Just the data from the "nodes" collection is lost.
So my question is now, how is it possible? Do I use flush and clear methods in dao layer incorrectly?
Or do I really need any kind of hibernate/database locking (but why should I need it when I delete all element rows with given hash before I persist them)?
If I understand it well in CMT is commit performed when the transaction ends.
Here is the log4j log:
[2015-01-22 17:02:49,944] 9023579 [Thread-208] DEBUG ElementDaoImpl Storing for hash ABCDE nodes nodes=[NodeEntity[1], NodeEntity[2]]
[2015-01-22 17:02:50,028] 9023663 [Thread-216] DEBUG ElementDaoImpl Storing for hash ABCDE nodes nodes=[NodeEntity[1], NodeEntity[2]]
[2015-01-22 17:02:50,727] 9024362 [Thread-208] DEBUG ElementDaoImpl CElementEntity nodes: []]
Thank you for every tip or advice how to improve the code.

Answer 1

You need to add #Version to your entities to enable optimistic locking and therefore prevent lost updates.
For that your entities need to contain the following field:
#Version
private int version;
Hibernate will take care of the rest.