Exam 2V0-72.22 topic 1 question 8 discussion

This is a poor set of avaiable answers: update() (there is no update1() method) will create a new transaction when executed, however update2() is REQUIRES_NEW which will suspend that transaction and create a new one, until it has completed, and then return to the suspended transaction begun by update(), thus: A is the most correct as there wuill be 2 transactions (even though one is suspended) B this is false, new transactions can be started within existing ones C is incorrect as it never uses an existing transaction (it suspends it) D is incorrect because update 2 does begin a new transaction and is within a proxy Therefore A is the most accurate in this context

n Spring, transaction management relies on Spring AOP (Aspect-Oriented Programming), which means transactions are managed through proxies. For a new transaction (like one specified with REQUIRES_NEW) to be started within an existing transaction, the method must be called through a Spring proxy. In the code provided, update1 calls update2 directly. This means the call does not go through the Spring proxy, and hence, the REQUIRES_NEW propagation on update2 is not recognized. As a result, there is only one transaction, which is the one initiated by update1. If update2 were to be called in a way that went through the proxy, such as through another Spring-managed bean, a new transaction would indeed be started because of the REQUIRES_NEW propagation. However, the direct call prevents this from happening, leading to only one transaction.

A is correct

Answer is D. Based on the lecture video from Vmware's training course (Spring framework essentials> Module 9 > Configure Transaction Propagation): The first update method will create a transaction and run in a proxy, and when the second update method is called, it will be executed within the same transaction in the same proxy.

The answer should be A. There should be two transactions. The first one will be suspended when the second one is called and once the second transaction is done, the first one will become active again. Please refer to the Spring Docs on the topic of Transaction propagation: https://docs.spring.io/spring-framework/reference/data-access/transaction/declarative/tx-propagation.html

The option D is correct due to this article, where this case resolved - https://www.marcobehler.com/guides/spring-transaction-management-transactional-in-depth

I think is A correct answer Option B is incorrect because an exception is not thrown when using REQUIRES_NEW propagation. Option C is incorrect because REQUIRES_NEW will always create a new transaction even if an active transaction is present. Option D is also incorrect because the call to update2() does go through the proxy and the transactional behavior will be applied.