JPA，Spring嵌套事务

Question

I have to persist an object O that contains a list of OL objects in one transaction:

@Entity
public class O {
  @OneToMany
  private List<OL> olist;

  // getters/setters
}

I'm reading O and OL from a file (xml interface) and have to insert them into the DB. The condition is the following: if an exception is thrown while persisting an OL object, ignore and continue with other OLs:

@Transactional
private persistO(...) {

  O o = new O();
  o.set(...);

  oDao.persist(o);

  for (int i = 0; i < olCount; i++) {
     OL ol = new OL();

     ol.set(...);

     try {
        olDao.persist(ol);
        em.flush();
     }
     catch(ConstraintViolationException ex) {
        logger.warn()...;
     }
  }

}`

The problem is that at the first ConstraintViolationException the transaction is set to rollbackOnly and nothing gets persisted.

org.springframework.transaction.TransactionSystemException: 
    Could not commit JPA transaction; 
      nested exception is javax.persistence.RollbackException: 
        Transaction marked as rollbackOnly

Question: How can this be achieved with JPA (Hibernate + Spring)?

Note

• I know that it might be possible to first make a query in the DB, make sure that the OL object doesn't exists yet, but let's assume the procedure is very complex and the performance would suffer a lot.
• The requirement doesn't allow me to persist the OL objects in new transactions (it s all or nothing), so @Transactional(propagation = Propagation.PROPAGATION_REQUIRES_NEW) cannot be used.

Answer 1

What you are describing sounds a bit self-contradictory, in terms of transactions. Transactions are meant to be all or nothing. Why would an OL add fail?

Reading between the lines, you are trying to do an add with no overwrite. That sounds a bit suspicious, from a design standpoint. How would there be existing OL without an existing O? You could using SQL to blindly delete any orphan OL, if that's what's going on. This also raises the question whether you. using surrogate keys.

You could add the new O and persist, before adding any OL instances. You could then flush and retrieve the O, which would retrieve any existing OL. You would then add your new OL and persist.