Transaction Propagation ve Rollback Yayılımı

1
@Service
2
class TransferService {
3

4
    private final AccountRepository accounts;
5
    private final FeeWaiverService waivers;
6
    private final AuditTrail audit;
7

8
    TransferService(AccountRepository accounts, FeeWaiverService waivers, AuditTrail audit) {
9
        this.accounts = accounts;
10
        this.waivers = waivers;
11
        this.audit = audit;
12
    }
13

14
    @Transactional
15
    public TransferReceipt transfer(TransferCommand cmd) {
16
        audit.record("transfer.attempt", cmd.customerId(), cmd.amount());   // survives a rollback below
17

18
        // No free-transfer right left is not an error: ask first, no exception involved.
19
        WaiverCheck waiver = waivers.check(cmd.customerId(), YearMonth.now());
20
        BigDecimal fee = waiver.free() ? BigDecimal.ZERO : cmd.standardFee();
21

22
        Account from = accounts.findForUpdate(cmd.fromIban());   // SELECT ... FOR UPDATE
23
        Account to = accounts.findForUpdate(cmd.toIban());
24
        from.debit(cmd.amount().add(fee));   // throws InsufficientFundsException: whole transfer rolls back
25
        to.credit(cmd.amount());
26

27
        if (waiver.free()) waivers.consume(cmd.customerId(), YearMonth.now());
28
        return new TransferReceipt(from.lastEntryId(), fee);
29
    }
30
}

1
@Service
2
class AuditTrail {
3

4
    private final AuditRepository repository;
5
    private final Clock clock;
6

7
    AuditTrail(AuditRepository repository, Clock clock) {
8
        this.repository = repository;
9
        this.clock = clock;
10
    }
11

12
    // Suspends the caller's transaction and commits on its own: a failed transfer
13
    // attempt still leaves a trace for the compliance team.
14
    // Costs a second connection from the pool while the outer one waits.
15
    @Transactional(propagation = Propagation.REQUIRES_NEW)
16
    public void record(String action, long customerId, BigDecimal amount) {
17
        repository.save(new AuditEntry(action, customerId, amount, Instant.now(clock)));
18
    }
19
}

1
@Service
2
class FeeWaiverService {
3

4
    private final FeeWaiverRepository waivers;
5

6
    FeeWaiverService(FeeWaiverRepository waivers) {
7
        this.waivers = waivers;
8
    }
9

10
    // Joins the caller's transaction (REQUIRED). If this threw a RuntimeException,
11
    // the shared transaction would be marked rollback-only; catching it in the caller
12
    // would then end in UnexpectedRollbackException at commit — and the transfer is lost.
13
    @Transactional(readOnly = true)
14
    public WaiverCheck check(long customerId, YearMonth month) {
15
        return waivers.findByCustomerAndMonth(customerId, month)
16
                .filter(w -> w.remaining() > 0)
17
                .map(w -> WaiverCheck.FREE)
18
                .orElse(WaiverCheck.CHARGED);
19
    }
20

21
    @Transactional
22
    public void consume(long customerId, YearMonth month) {
23
        waivers.findByCustomerAndMonth(customerId, month).orElseThrow().useOne();
24
    }
25
}

1
@Service
2
class PayrollFileProcessor {
3

4
    private final SalaryPayer payer;   // a separate bean: calls go through its proxy
5

6
    PayrollFileProcessor(SalaryPayer payer) {
7
        this.payer = payer;
8
    }
9

10
    // A company uploads one file for all its employees. No transaction here:
11
    // each salary gets its own, so a closed account fails alone and the rest are paid.
12
    public PayrollReport process(PayrollFile file) {
13
        var report = new PayrollReport(file.id());
14
        for (PayrollLine line : file.lines()) {
15
            try {
16
                payer.pay(file.companyIban(), line);
17
                report.paid(line);
18
            } catch (RuntimeException ex) {
19
                report.rejected(line, ex.getMessage());   // sent back to the company
20
            }
21
        }
22
        return report;
23
    }
24
}
25

26
@Service
27
class SalaryPayer {
28

29
    private final AccountRepository accounts;
30

31
    SalaryPayer(AccountRepository accounts) {
32
        this.accounts = accounts;
33
    }
34

35
    @Transactional(propagation = Propagation.REQUIRES_NEW)
36
    public void pay(String companyIban, PayrollLine line) {
37
        accounts.findForUpdate(companyIban).debit(line.amount());
38
        accounts.findForUpdate(line.employeeIban()).credit(line.amount());
39
    }
40
}

1
@Service
2
class AutoBillPayments {
3

4
    private final TransactionTemplate perBill;
5
    private final BillPaymentRepository bills;
6

7
    AutoBillPayments(PlatformTransactionManager txManager, BillPaymentRepository bills) {
8
        this.perBill = new TransactionTemplate(txManager);
9
        this.perBill.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
10
        this.bills = bills;
11
    }
12

13
    // Same idea as SalaryPayer, without a second bean: the boundary is explicit in code.
14
    // Electricity, water, phone: one bill failing for lack of funds must not undo the others.
15
    public int payDueToday(List<DueBill> due) {
16
        int paid = 0;
17
        for (DueBill bill : due) {
18
            try {
19
                perBill.executeWithoutResult(status -> bills.payFromAccount(bill));
20
                paid++;
21
            } catch (RuntimeException ex) {
22
                // this bill rolled back and will be retried tomorrow; the others are unaffected
23
            }
24
        }
25
        return paid;
26
    }
27
}

1
logging:
2
  level:
3
    # "Creating new transaction", "Participating in existing transaction",
4
    # "Suspending current transaction" — the propagation decisions, line by line.
5
    org.springframework.orm.jpa.JpaTransactionManager: DEBUG
6
    org.springframework.transaction.interceptor: TRACE