Spring @Transactional: Propagation and Isolation

//Account.java
package com.javabrahman.data.tx;

import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;

@Entity
public class Account {
  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  private Long id;
  private String owner;
  private long balance;

  protected Account() {
  }

  public Account(String owner, long balance) {
    this.owner = owner;
    this.balance = balance;
  }

  public Long getId() { return id; }
  public String getOwner() { return owner; }
  public long getBalance() { return balance; }
  public void setBalance(long balance) { this.balance = balance; }
}

//AuditEntry.java
package com.javabrahman.data.tx;

import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;

@Entity
public class AuditEntry {
  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  private Long id;
  private String message;

  protected AuditEntry() {
  }

  public AuditEntry(String message) {
    this.message = message;
  }

  public String getMessage() { return message; }
}

//AccountRepository.java
package com.javabrahman.data.tx;

import org.springframework.data.jpa.repository.JpaRepository;

public interface AccountRepository extends JpaRepository<Account, Long> {
  Account findByOwner(String owner);
}

//AuditRepository.java
package com.javabrahman.data.tx;

import org.springframework.data.jpa.repository.JpaRepository;

public interface AuditRepository extends JpaRepository<AuditEntry, Long> {
}

//AuditService.java
package com.javabrahman.data.tx;

import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

@Service
public class AuditService {
  private final AuditRepository audit;

  public AuditService(AuditRepository audit) {
    this.audit = audit;
  }

  @Transactional   // propagation = REQUIRED, the default: join the caller's transaction
  public void logJoined(String message) {
    audit.save(new AuditEntry(message));
  }

  @Transactional(propagation = Propagation.REQUIRES_NEW)   // suspend the caller's, run in its own
  public void logInOwnTransaction(String message) {
    audit.save(new AuditEntry(message));
  }

  @Transactional(propagation = Propagation.MANDATORY)   // a caller's transaction must exist
  public void logMandatory(String message) {
    audit.save(new AuditEntry(message));
  }

  @Transactional   // joins the caller's transaction and fails inside it
  public void logAndFail(String message) {
    audit.save(new AuditEntry(message));
    throw new IllegalStateException("audit failed");
  }
}

//TransferService.java
package com.javabrahman.data.tx;

import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class TransferService {
  private final AccountRepository accounts;
  private final AuditService auditService;

  public TransferService(AccountRepository accounts, AuditService auditService) {
    this.accounts = accounts;
    this.auditService = auditService;
  }

  @Transactional
  public void transfer(String from, String to, long amount) {
    Account source = accounts.findByOwner(from);
    Account target = accounts.findByOwner(to);
    source.setBalance(source.getBalance() - amount);   // no save() needed: dirty checking
    target.setBalance(target.getBalance() + amount);
    if (source.getBalance() < 0) {
      throw new IllegalStateException("insufficient funds in " + from + "'s account");
    }
  }

  @Transactional
  public void transferThenCheckedException(String from, String to, long amount) throws Exception {
    transfer(from, to, amount);   // a plain method call here: no new transaction
    throw new Exception("checked exception after the transfer");
  }

  @Transactional(rollbackFor = Exception.class)
  public void transferThenCheckedExceptionRollback(String from, String to, long amount) throws Exception {
    transfer(from, to, amount);
    throw new Exception("checked exception after the transfer");
  }

  // NOT transactional, and calls transfer() on "this" - the proxy is bypassed
  public void transferViaSelfCall(String from, String to, long amount) {
    transfer(from, to, amount);
  }

  @Transactional
  public void transferWithAudit(String from, String to, long amount) {
    auditService.logInOwnTransaction("attempt: " + from + " to " + to + " " + amount);
    auditService.logJoined("joined: " + from + " to " + to + " " + amount);
    transfer(from, to, amount);
  }

  @Transactional
  public void catchInnerFailure() {
    try {
      auditService.logAndFail("inner work");
    } catch (IllegalStateException e) {
      System.out.println("   caught inside the outer method: " + e.getMessage());
    }
  }

  @Transactional(readOnly = true)
  public void changeInReadOnly(String owner) {
    accounts.findByOwner(owner).setBalance(1_000_000);
  }
}

//TxApp.java
package com.javabrahman.data.tx;

import java.util.concurrent.CountDownLatch;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.TransactionDefinition;
import org.springframework.transaction.support.TransactionTemplate;

@SpringBootApplication
public class TxApp {

  @Bean
  CommandLineRunner demo(TransferService transfers, AuditService auditService, AccountRepository accounts,
                         AuditRepository audit, PlatformTransactionManager txManager) {
    return args -> {
      accounts.save(new Account("alice", 100));
      accounts.save(new Account("bob", 100));
      System.out.println("transaction manager: " + txManager.getClass().getSimpleName());
      balances(accounts, "start");

      run("1. transfer 30, no exception", () -> transfers.transfer("alice", "bob", 30));
      balances(accounts, "after 1");

      run("2. transfer 500, runtime exception", () -> transfers.transfer("alice", "bob", 500));
      balances(accounts, "after 2");

      run("3. transfer 10, then checked exception", () -> transfers.transferThenCheckedException("alice", "bob", 10));
      balances(accounts, "after 3");

      run("4. transfer 10, checked exception, rollbackFor", () -> transfers.transferThenCheckedExceptionRollback("alice", "bob", 10));
      balances(accounts, "after 4");

      run("5. transfer 20 through a self-call", () -> transfers.transferViaSelfCall("alice", "bob", 20));
      balances(accounts, "after 5");

      run("6. transfer 500 with audit (REQUIRES_NEW and REQUIRED)", () -> transfers.transferWithAudit("alice", "bob", 500));
      balances(accounts, "after 6");
      audit.findAll().forEach(e -> System.out.println("   audit row: " + e.getMessage()));

      run("7. MANDATORY without a transaction", () -> auditService.logMandatory("no caller transaction"));

      run("8. inner REQUIRED method fails, outer catches", transfers::catchInnerFailure);

      run("9. change inside readOnly = true", () -> transfers.changeInReadOnly("alice"));
      balances(accounts, "after 9");

      isolation(txManager, accounts, TransactionDefinition.ISOLATION_READ_COMMITTED);
      isolation(txManager, accounts, TransactionDefinition.ISOLATION_READ_UNCOMMITTED);
    };
  }

  // Writer changes alice's balance and waits before rolling back; reader reads it meanwhile
  private static void isolation(PlatformTransactionManager txManager, AccountRepository accounts, int level)
      throws InterruptedException {
    String name = level == TransactionDefinition.ISOLATION_READ_COMMITTED ? "READ_COMMITTED" : "READ_UNCOMMITTED";
    System.out.println("== isolation " + name);
    CountDownLatch written = new CountDownLatch(1);
    CountDownLatch read = new CountDownLatch(1);

    Thread writer = new Thread(() -> new TransactionTemplate(txManager).executeWithoutResult(status -> {
      Account alice = accounts.findByOwner("alice");
      alice.setBalance(999);
      accounts.flush();            // send the update to the database, not yet committed
      written.countDown();
      await(read);
      status.setRollbackOnly();    // and then roll it back
    }));

    TransactionTemplate readerTx = new TransactionTemplate(txManager);
    readerTx.setIsolationLevel(level);
    Thread reader = new Thread(() -> readerTx.executeWithoutResult(status -> {
      await(written);
      System.out.println("   reader sees alice's balance: " + accounts.findByOwner("alice").getBalance());
      read.countDown();
    }));

    writer.start();
    reader.start();
    writer.join();
    reader.join();
    balances(accounts, "after the writer rolled back");
  }

  private static void await(CountDownLatch latch) {
    try {
      latch.await();
    } catch (InterruptedException e) {
      Thread.currentThread().interrupt();
    }
  }

  private static void run(String label, ThrowingRunnable work) {
    System.out.println("== " + label);
    try {
      work.run();
      System.out.println("   completed normally");
    } catch (Exception e) {
      System.out.println("   " + e.getClass().getSimpleName() + ": " + e.getMessage());
    }
  }

  private static void balances(AccountRepository accounts, String when) {
    System.out.println("   " + when + ": alice " + accounts.findByOwner("alice").getBalance()
        + ", bob " + accounts.findByOwner("bob").getBalance());
  }

  interface ThrowingRunnable {
    void run() throws Exception;
  }

  public static void main(String[] args) {
    SpringApplication.run(TxApp.class, args);
  }
}