İzolasyon Seviyeleri — Aynı İsim, Üç Farklı Davranış

1
interface AccountRepository extends JpaRepository<Account, String> {
2

3
    // Way 1: the database does the arithmetic. 0 rows updated means insufficient funds.
4
    // A bulk UPDATE skips @Version, so the version is bumped by hand.
5
    @Modifying
6
    @Query("""
7
            UPDATE Account a
8
               SET a.balance = a.balance - :amount, a.version = a.version + 1
9
             WHERE a.iban = :iban AND a.currency = :currency AND a.balance >= :amount
10
            """)
11
    int debitIfCovered(String iban, BigDecimal amount, String currency);
12

13
    // Way 2: SELECT ... FOR UPDATE on PostgreSQL and Oracle, an UPDLOCK hint on SQL Server.
14
    @Lock(LockModeType.PESSIMISTIC_WRITE)
15
    @Query("SELECT a FROM Account a WHERE a.iban = :iban")
16
    Optional<Account> findForUpdate(String iban);
17
}

1
@Entity
2
class Account {
3

4
    @Id
5
    private String iban;
6
    private String currency;                 // ISO 4217
7
    private BigDecimal balance;              // numeric(19,2) column
8

9
    // Way 3: Hibernate writes UPDATE ... WHERE version = ?; 0 rows means someone else won.
10
    @Version
11
    private long version;
12

13
    void debit(BigDecimal amount, String inCurrency) {
14
        if (!currency.equals(inCurrency)) throw new CurrencyMismatchException(iban, inCurrency);
15
        if (balance.compareTo(amount) < 0) throw new InsufficientFundsException(iban);
16
        balance = balance.subtract(amount);
17
    }
18
}

1
@Service
2
class CardWithdrawal {
3

4
    private static final int MAX_ATTEMPTS = 3;
5

6
    private final AccountRepository accounts;
7
    private final TransactionTemplate tx;
8

9
    CardWithdrawal(AccountRepository accounts, TransactionTemplate tx) {
10
        this.accounts = accounts;
11
        this.tx = tx;
12
    }
13

14
    // Not @Transactional itself: every attempt must start a fresh transaction.
15
    void withdraw(String iban, BigDecimal amount, String currency) {
16
        for (int attempt = 1; ; attempt++) {
17
            try {
18
                tx.executeWithoutResult(status ->
19
                        accounts.findById(iban).orElseThrow().debit(amount, currency));
20
                return;
21
            } catch (ConcurrencyFailureException e) {
22
                // Optimistic conflict, serialization failure or deadlock victim: all mean "try again".
23
                if (attempt == MAX_ATTEMPTS) throw e;
24
            }
25
        }
26
    }
27
}

1
// Reads fine and passes every single-user test.
2
@Transactional
3
public void withdraw(String iban, BigDecimal amount) {
4
    BigDecimal balance = jdbc.queryForObject(
5
            "SELECT balance FROM account WHERE iban = ?", BigDecimal.class, iban);
6
    if (balance.compareTo(amount) < 0) throw new InsufficientFundsException(iban);
7

8
    // Under READ COMMITTED two ATMs can both read the same balance above.
9
    // Both write their own result here, and one withdrawal disappears.
10
    jdbc.update("UPDATE account SET balance = ? WHERE iban = ?", balance.subtract(amount), iban);
11
}