About the use of @Transactional

Question

I have got a method where it will update two tables (table A and table B). I would want the whole transaction to be atomic so that if updating table A failed (either the database update failed, or the code thrown exception before making the actual database call), then it will not update table B so as to preserve data consistency. My questions:

I think of using @Transactional annotation to do so, is this usage correct ?
I have seen some placing the @Transactional at both the class level and also the method level, if I only put at the method level, will it still work ?
Suppose for the following. If I only place @Transactional in the private method of updateValue, does it mean only the update action from tableADao.updateValue(value) and tableBDao.updateValue(value) (but not tableADao.get(userId)) will be wrapped inside one transaction ?

public void updateMethod(final Long userId, Integer value) {
  //some processing
  Integer value = tableADao.get(userId);
  //some processing

  updateValue(value);
  //some processing
}

@Transactional
private void updateValue(final Integer value) {
  tableADao.updateValue(value);
  tableBDao.updateValue(value);
}

Your understanding of `@Transactional` seems to be correct. You may also want to add `@Modifying` to the method. — Tim Biegeleisen, Aug 30 '21 at 03:40
https://stackoverflow.com/questions/5109343/transactional-method-called-from-another-method-doesnt-obtain-a-transaction — chrylis -cautiouslyoptimistic-, Aug 30 '21 at 04:00
For the topic "@Transaction on private method" see https://stackoverflow.com/questions/4396284/does-spring-transactional-attribute-work-on-a-private-method — Ralph, Aug 30 '21 at 09:31

score 0 · Answer 1 · answered Aug 30 '21 at 09:55

Yes, @Transactional is suited for this.
Yes, @Transactional also works at method level, but with a catch that I will address in the following topic (this also applies to @Transactional at class level).
Assuming your code, that would not work, the reason being the way Spring provides transactional functionality. It is based on Spring AOP and on a Proxy for your bean. Transactional functionality is handled by this Proxy, but the catch is that only the calls from another bean to your bean are going through this Proxy. This means that calls between methods in the same bean do not go through the Proxy and as a consequence transactional functionality is not provided. Having said that, unless you add @Transactional to your public updateMethod method and you call it from another bean, your code will not work as you expect.

Check the comments to your question, there are some useful links there.

About the use of @Transactional

1 Answers1