Transactions

@Service
@Transactional  // class-level default: all public methods are transactional
public class OrderService {

    // Inherits class-level @Transactional
    public Order createOrder(CreateOrderRequest req) {
        Order order = orderRepository.save(new Order(req));
        inventoryService.reserve(req.items()); // same transaction
        paymentService.charge(req.paymentMethod(), order.total()); // same transaction
        // If paymentService.charge() throws → entire transaction rolls back
        return order;
    }

    // Override: read-only hint (enables flush-mode optimization)
    @Transactional(readOnly = true)
    public Order findById(String id) {
        return orderRepository.findById(id).orElseThrow();
    }

    // Roll back on checked exception too
    @Transactional(rollbackFor = PaymentException.class)
    public void processRefund(String orderId) throws PaymentException {
        // ...
    }

    // ❌ Self-invocation — proxy is bypassed, NO transaction started
    public void methodA() {
        this.methodB(); // calls target, not proxy — @Transactional ignored!
    }

    @Transactional
    public void methodB() { /* ... */ }
}

@Service
public class AuditService {

    // REQUIRES_NEW — suspends outer transaction, commits independently
    // Use for: audit logs, notifications, anything that must NOT rollback
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void logAction(String userId, String action) {
        auditRepository.save(new AuditLog(userId, action, Instant.now()));
        // This ALWAYS commits, even if the caller's transaction rolls back
    }
}

@Service
public class PaymentService {

    private final AuditService auditService;

    @Transactional
    public void charge(String userId, BigDecimal amount) {
        // outer transaction T1
        processCharge(userId, amount);
        auditService.logAction(userId, "PAYMENT_CHARGED"); // T2 — new transaction
        if (someCondition) {
            throw new RuntimeException(); // T1 rolls back, T2 already committed
        }
    }
}

// Propagation summary:
// REQUIRED       — join existing; create new if none (default)
// REQUIRES_NEW   — always new transaction; suspend existing
// SUPPORTS       — join if exists; non-transactional if none
// NOT_SUPPORTED  — run non-transactionally; suspend existing
// MANDATORY      — must have existing transaction; throw if none
// NEVER          — must NOT have transaction; throw if one exists
// NESTED         — nested savepoint within existing (rollback to savepoint)

// Isolation levels and anomalies they prevent:
// READ_UNCOMMITTED — can read dirty (uncommitted) data. No locks. Fastest.
// READ_COMMITTED   — can't read dirty data. Default for PostgreSQL/Oracle.
// REPEATABLE_READ  — repeated reads of same row return same value. Default for MySQL.
// SERIALIZABLE     — full isolation. Slowest. Transactions execute as if sequential.

// Anomalies:
// Dirty Read       — reading uncommitted data from another transaction
// Non-repeatable  — same row reads different values within one transaction
// Phantom Read     — range query returns different rows on repeated reads

@Transactional(isolation = Isolation.REPEATABLE_READ)
public OrderSummary generateReport(String customerId) {
    // First read — 5 orders
    List<Order> orders = orderRepository.findByCustomerId(customerId);
    BigDecimal total = orders.stream().map(Order::getTotal).reduce(ZERO, BigDecimal::add);
    // ... heavy processing ...
    // Second read of same data guaranteed to return same rows (no phantom)
    return new OrderSummary(orders.size(), total);
}

// For most web apps: READ_COMMITTED is sufficient
// Use SERIALIZABLE only for financial ledger / inventory reservation
// Optimistic locking (@Version) is often better than higher isolation