@Transactional noRollbackFor EmptyResultDataAccessException.class is not working

Question

I would like to ignore the exception and commit the transaction anyway. However, every time I get a error. What exactly is the problem and how can I solve it?

@Transactional( noRollbackFor = EmptyResultDataAccessException.class )
   public Foo foo( Foo foo, String barId ) {
    Foo foo = fooRepository.save(foo)
    deleteBarSilently(barId)
      return foo ;
   }


   //@Transactional( noRollbackFor = EmptyResultDataAccessException.class )
   private void deleteBarSilently( final String barId) {

      try {
         barRepository.deleteById( barId);
      } catch ( final EmptyResultDataAccessException ignored ) {
         System.out.println( ignored );
      }
   }

Error is: org.springframework.transaction.TransactionSystemException: Could not commit JPA transaction; nested exception is javax.persistence.RollbackException: Transaction "rolled back" because transaction was set to RollbackOnly.

Exception is EmptyResultDataAccessException

EDIT: Also tried it with try/catch and without and with a array of exception @Transactional( noRollbackFor = {EmptyResultDataAccessException.class} ) and with fullqualified class name

Log without catch

Application exception overridden by commit exception

org.springframework.dao.EmptyResultDataAccessException: No class com.bosch.bci.foundation.digitaltwin.repository.domain.ModelReference entity with id c16675da-f5ce-46b1-97e6-7eb6869940aa exists!
    at org.springframework.data.jpa.repository.support.SimpleJpaRepository.lambda$deleteById$0(SimpleJpaRepository.java:166) ~[spring-data-jpa-2.5.3.jar:2.5.3]

Log with catch is just

org.springframework.transaction.TransactionSystemException: Could not commit JPA transaction; nested exception is javax.persistence.RollbackException: Transaction "rolled back" because transaction was set to RollbackOnly.

Answer 1

noRollbackFor expects an array of Throwable subclasses instead you are passing only a class (EmptyResultDataAccessException)

Try changing to (note the curly braces "{" and "}" which signify the array):

@Transactional( noRollbackFor = { EmptyResultDataAccessException.class })

UPDATE

It seems that since EmptyResultDataAccessException is a RuntimeException trying not to rollback upon hitting it is not a case, unless you globally set globalRollbackOnParticipationFailure=false.

Solution 1

The first solution is to implement your own barRepository.deleteById( barId) which does not throw EmptyResultDataAccessException

e.g.

in your BarRepository create the following method:

@Transactional
@Modifying
@Query("DELETE FROM Bar b WHERE b.id= :id")
void customDeleteById(Long id);

and in your deleteBarSilently remove the try catch and simply have:

@Transactional
private void deleteBarSilently( final Long barId) {
     barRepository.customDeleteById( barId);
}

Solution 2

In the second solution you can change your code to the following to run the deleteBarSilently outside of the transaction of foo so when you hit the EmptyResultDataAccessException simply try catch it and no rollback will occur.

Firstly you need to separate your methods to different services (for @Transactional annotation to work), lets say FooService and BarService,

FooService

@Service
public class FooService {

    @Autowired
    private FooRepository fooRepository;

    @Autowired
    private BarService barService;

    @Transactional
    public Student foo( Foo foo, Long barId ) {
        Foo savedFoo = fooRepository.save(foo);
        barService.deleteBarSilently(barId);
        return savedFoo ;
    }
}

BarService

Annotate the method with @Transactional(propagation = Propagation.NOT_SUPPORTED) which will cause the transaction to suspend, execute the method's code outside of transaction and then resume.

@Service
public class BarService {

    @Autowired
    private BarRepository barRepository;

    @Transactional(propagation = Propagation.NOT_SUPPORTED)
    public void deleteBarSilently( final Long barId) {
        try {
            barRepository.deleteById( barId);
        } catch (EmptyResultDataAccessException exc) {
            System.out.println(exc);
        }
    }
}