The document discusses various transaction management patterns and anti-patterns, noting that the declarative transaction model using annotations or XML is preferred as it removes transaction logic from code. It describes common transaction patterns like open session in view and domain service owner that help define transaction boundaries and control, while also touching on other concepts like propagation and long running transactions. Developers are advised to use declarative patterns to clearly define transaction strategy and minimize bugs.

1. Transaction Management Patterns Ruslan Platonov Lead Java Developer at C.T.Co

4. Consistency

5. Isolation

6. Durability

8. Not clear understanding (knowledge) of transaction management strategy on application level

9. DB team should care about transactions

10. All these things results in anti patterns inside our projects

12. hibernate.connection.release_mode = after_statement

13. Ex 2: Programmatic Control Connection connection = null ; Statement statement = null ; try { Class. forName ( "driverClass" ); connection = DriverManager.getConnection( "url" , "user" , "pass" ); connection.setAutoCommit( false ); statement = connection.createStatement(); // Execute queries statement.executeUpdate( "UPDATE Table1 SET Value = 1 WHERE Name = 'foo'" ); statement.executeUpdate( "UPDATE Table2 SET Value = 2 WHERE Name = 'bar'" ); connection.commit(); } catch (SQLException ex) { if ( null != connection) { connection.rollback(); } } finally { if ( null != statement) { statement.close(); } if ( null != connection) { connection.close(); } }

14. Ex 3: Incorrect Demarcation @ Repository public class UserRepository { @ Transactional public void save(User user) { ... } } @ Component public class UserService { @ Autowired private UserRepository repo ; public void disableUsers( List<User> usersList) { for (User user : usersList) { repo .save(user); } } }

15. Ex 4: Batch processing @ Component public class LongRunningJob { @ Autowired private RecordRepository repository ; @ Transactional public void updateRecords() { for ( int i = 1; i < 100000; i++) { Record rec = repository .getById(i); repository .updateTimeStamp(rec, new Date()); } } }

17. Performance Issues

18. High load on DB

19. How can we improve our code?

21. Add transparency

22. Decouple from application logic, make flexible

23. Simplify maintenance

24. Transaction Models

26. Programmatic

27. Declarative

29. Developer manage connections not transaction

30. Local Transaction Model Example

32. Suitable for simple cases

33. Plenty of room for errors

34. Cannot maintain ACID when coordinating multiple resources (DB, JMS)

36. Developer is responsible for starting and terminating transactions

37. Programmatic Transaction Model Example

38. Programmatic Transaction Model with Decorator public class AccountServiceDecorator implements AccountService { private AccountService service ; public AccountServiceDecorator(AccountService service) {...} public boolean transfer(Amount amount, Account debetAcc, Account creditAcc { boolean transferred = false ; try { startTransaction(); transferred = service .transfer(amount, debetAcc, creditAcc); commit(); } catch (RuntimeException e) { rollback(); throw e; } return transferred; } }

41. Localized JTA transactions

44. No Java code for transaction management

45. Developer only tells the container how to manage transactions

46. Declarative Transaction Model with ASPECT (1) public class AccountServiceImpl implements AccountService { @ Transactional public boolean transferAmount( final Amount amount, final Account debetAcc, final Account creditAcc) { ..... } }

47. Declarative Transaction Model with ASPECT (2) @ Aspect public class TransactionAspect { private TransactionService transactionService = new TransactionServiceNull(); @ Pointcut( &quot;execution(@org.spring...Transactional * *(..))&quot; ) public void transactionalMethod() {} public void setTransactionService( final TransactionService transactionService) { this . transactionService = transactionService; } .... to be continued ....

48. Declarative Transaction Model with ASPECT (3) ... continued ... @ Before( &quot;transactionalMethod()&quot; ) public void beforeTransactionalMethod(JoinPoint joinPoint) { transactionService.beginTransaction(); } @ AfterReturning( &quot;transactionalMethod()&quot; ) public void afterTransactionalMethod(JoinPoint joinPoint) { transactionService .commit(); } @ AfterThrowing(pointcut = &quot;transactionalMethod()&quot; , throwing = &quot;e&quot; ) public void afterThrowingFromTransactionalMethod(JoinPoint joinPoint, RuntimeException e) { transactionService.rollback(); } }

49. Declarative Transaction Model with Spring Annotations <context:component-scan base-package=&quot;com........&quot; /> <tx:annotation-driven /> <bean id=&quot;txnMgr&quot; class=&quot;org.springframework.jdbc.datasource.DataSourceTransactionManager&quot;> <property name=&quot;dataSource&quot; ref=&quot;dataSource&quot;/> </bean> @ Component public class UsersService { @ Transactional(propagation = Propagation.REQUIRED) public void modifyUser(User user) { ... } }

50. Declarative Transaction Model with Spring XML Configuration

52. Mandatory – reuse but never starts new

53. RequiresNew – always starts new

54. Supports – not require, but uses if present

55. NotSupported – suspends TX if present

56. Never – cannot be invoked with TX (throws exception)

57. Transaction Design Patterns

59. Client Owner

60. Domain Service Owner

61. Server Delegate Owner

63. Whole request is responsible for transaction management

66. Single entry point for configuration

67. May lead to performance issues when mapped to any request

69. Doesn't support long transactions

72. Most suitable for fine-grained application services

73. Application and underlying layers should never take control over transactions

74. Most suitable for cases when application layer architecture can't be changed

77. Services are course-grained (Facades)

78. Domain and persistence layers should never take control over transactions

79. Client doesn't contain any transaction logic

81. External system / services facades own the transaction

82. Server Delegate Owner Pattern Example @ Component @ Transactional public class UpdateRateCommand { private CurrencyRateSystem crs ; private RateData data ; public UpdateRateCommand(RateData data) { this . data = data; } public void execute() { Currency currFrom = data .getFrom(); Currency currTo = data .getTo(); Rate rate = crs .rate(currFrom, currTo, new Date()); data .setRate(rate); } }

84. Transactions are not managed by presentation and services layers

86. Java Transaction Service (JTS) and Java Transaction API (JTA)

87. XA Transaction processing

88. Transaction management in JMS

89. Long running transactions

90. …and more

92. Define transaction boundaries correctly

94. Clearly define transaction management strategy

95. Make code easy to understand, implement and maintain

96. Minimize amount of bugs

97. Thank you! Questions?

99. http://blog.smartkey.co.uk/2010/03/open-session-in-view-pattern-spring-jpa/