Transactions

🔍 What Is It?

Spring's @Transactional annotation manages database transactions declaratively.

What @Transactional does:

1. Opens a transaction before the method runs
2. Commits if the method returns normally
3. Rolls back if a RuntimeException (or configured exception) is thrown
4. Handles transaction propagation (joining existing or starting new)

Key attributes:

• →propagation — how to handle existing transactions (REQUIRED, REQUIRES_NEW, etc.)
• →isolation — isolation level (READ_COMMITTED, REPEATABLE_READ, etc.)
• →readOnly — hint for optimization (no dirty checking, read replicas)
• →rollbackFor — exceptions that trigger rollback (default: RuntimeException)
• →noRollbackFor — exceptions that don't trigger rollback
• →timeout — transaction timeout in seconds

🎯 Why Do We Need It?

Without transactions, partial failures leave your database in inconsistent states:

// WITHOUT @Transactional — dangerous!
public void transferMoney(Long fromId, Long toId, BigDecimal amount) {
    accountRepository.debit(fromId, amount);   // succeeds
    // *** Server crashes here ***
    accountRepository.credit(toId, amount);    // never runs
    // Money is gone! Database is inconsistent.
}

// WITH @Transactional — safe
@Transactional
public void transferMoney(Long fromId, Long toId, BigDecimal amount) {
    accountRepository.debit(fromId, amount);
    accountRepository.credit(toId, amount);
    // Either both succeed or both roll back
}

🏗️ What Happens in Real Projects?

@Transactional is on every service method that writes to the database. @Transactional(readOnly=true) on every service method that only reads. Complex operations (order placement, payment processing, inventory reservation) must be in a single transaction to maintain consistency.

⚙️ How It Works

Spring creates a proxy around your @Transactional class. When you call a method, the proxy:

1. Checks if there's an existing transaction (based on propagation)
2. Opens a new transaction or joins existing
3. Calls your method
4. Commits or rolls back based on the outcome

The self-invocation trap:

When a method in a class calls another method in the SAME class, the call bypasses the proxy. The @Transactional annotation on the inner method is ignored. This is the #1 Spring transaction bug.

💻 Example

Transaction Management in Practice — Propagation, isolation, rollback rules, and common pitfalls.

@Service
@Transactional  // Default for all write methods in this service
public class OrderService {

    // Inherits class-level @Transactional (REQUIRED propagation)
    public Order placeOrder(CreateOrderRequest request) {
        // All these run in ONE transaction
        Order order = orderRepository.save(Order.from(request));
        inventoryService.reserve(request.getItems());  // joins same transaction
        paymentService.charge(order);                  // joins same transaction
        notificationService.sendConfirmation(order);   // joins same transaction
        return order;
        // If ANY of these throw RuntimeException, ALL changes roll back
    }

    // Read-only — no dirty checking, can use read replica
    @Transactional(readOnly = true)
    public Page<OrderSummaryDto> findOrders(Long customerId, Pageable pageable) {
        return orderRepository.findByCustomerId(customerId, pageable)
            .map(OrderSummaryDto::from);
    }

    // Requires a NEW transaction — commits independently of the caller
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void logAuditEvent(AuditEvent event) {
        // This transaction commits even if the caller's transaction rolls back
        auditRepository.save(event);
    }

    // Rollback on checked exception too
    @Transactional(rollbackFor = Exception.class)
    public void processPayment(Long orderId) throws PaymentException {
        // Rolls back on PaymentException (checked) AND RuntimeException
    }

    // Timeout — rolls back if takes more than 30 seconds
    @Transactional(timeout = 30)
    public void generateReport() {
        // Long-running operation with timeout guard
    }
}

🤔 Common Confusions

🚨 Common Production Issues

✅ Best Practices

🏛️ Architect's Note

💬 Frequently Asked Questions

🎯 Key Takeaways

🔗 Related Topics

🎯 Practice this topic in interviews

↗ Where this topic fits