Devops Monk

@Service
public class OrderService {

    // Called from outside — proxy intercepts — transaction works ✓
    @Transactional
    public void placeOrder(OrderRequest request) {
        // ...
        sendConfirmation(request); // PROBLEM: direct call, no proxy involved
    }

    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void sendConfirmation(OrderRequest request) {
        // This runs in the SAME transaction as placeOrder, not a new one
        // The @Transactional annotation here is effectively ignored
    }
}

@Service
public class OrderService {

    @Autowired
    private OrderService self; // Spring injects the proxy

    @Transactional
    public void placeOrder(OrderRequest request) {
        self.sendConfirmation(request); // goes through proxy ✓
    }

    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void sendConfirmation(OrderRequest request) { ... }
}

@Transactional(propagation = Propagation.REQUIRED)
public void doWork() { ... }

@Transactional(propagation = Propagation.REQUIRES_NEW)
public void auditLog(String message) { ... }

@Service
@Transactional
public class OrderService {

    private final AuditService auditService; // has REQUIRES_NEW

    public void placeOrder(Order order) {
        saveOrder(order);
        auditService.log("order placed: " + order.getId()); // commits independently
        if (someConditionFails()) {
            throw new RuntimeException(); // outer tx rolls back, audit log survives
        }
    }
}

@Transactional(propagation = Propagation.SUPPORTS)
public Product findProduct(Long id) { ... }

@Transactional(propagation = Propagation.NOT_SUPPORTED)
public void sendEmail(String to, String body) { ... }

@Transactional(propagation = Propagation.MANDATORY)
public void mustRunInTx() { ... }

@Transactional(propagation = Propagation.NEVER)
public void mustNotRunInTx() { ... }

@Transactional(propagation = Propagation.NESTED)
public void nestedOperation() { ... }

@Transactional(isolation = Isolation.READ_COMMITTED)
public void doWork() { ... }

@Transactional(isolation = Isolation.READ_COMMITTED)
public ReportData generateReport() {
    // Each query sees the latest committed data
    // Two reads of the same row may return different values
    // Good for reporting where stale data is acceptable
}

@Transactional(isolation = Isolation.REPEATABLE_READ)
public void transferFunds(Long fromId, Long toId, BigDecimal amount) {
    // Reading the same row twice gives the same result
    // Phantom rows (new rows inserted by other tx) are still possible (on some DBs)
}

@Transactional(isolation = Isolation.SERIALIZABLE)
public void criticalInventoryUpdate() {
    // Complete isolation — as if transactions ran one by one
    // Highest consistency, lowest throughput
}

@Transactional
public void riskyOperation() throws IOException {
    // RuntimeException → ROLLBACK ✓ (default)
    // IOException (checked) → COMMIT (default — surprising!)
}

@Transactional(rollbackFor = IOException.class)
public void riskyOperation() throws IOException {
    // Now IOException also triggers rollback
}

@Transactional(rollbackFor = Exception.class)
public void paranoidOperation() throws Exception {
    // Any exception triggers rollback
}

@Transactional(noRollbackFor = OptimisticLockException.class)
public void handleConcurrentUpdate() {
    // OptimisticLockException (RuntimeException) is caught and handled
    // Transaction commits rather than rolling back
}

@Transactional(rollbackFor = BusinessException.class)
public void placeOrder(OrderRequest request) {
    if (!inventoryService.isAvailable(request.getProductId())) {
        throw new InsufficientStockException("Out of stock"); // BusinessException subclass
    }
    // ...
}

@Transactional(readOnly = true)
public List<Product> findActiveProducts() {
    return productRepository.findByActiveTrue();
}

@Service
@Transactional(readOnly = true)  // default for all methods
public class ProductService {

    public List<Product> findAll() { ... }     // read-only ✓
    public Product findById(Long id) { ... }   // read-only ✓

    @Transactional  // override for writes (readOnly = false)
    public Product save(Product product) { ... }

    @Transactional
    public void delete(Long id) { ... }
}

@Transactional(timeout = 30) // seconds
public void slowOperation() {
    // Throws TransactionTimedOutException if not done in 30s
}

@Service
@Transactional(readOnly = true)
public class OrderService {

    private final OrderRepository orderRepository;
    private final ProductRepository productRepository;
    private final AuditService auditService;

    // Read-only — inherits class-level @Transactional(readOnly=true)
    public Page<Order> findByCustomer(Long customerId, Pageable pageable) {
        return orderRepository.findByCustomerId(customerId, pageable);
    }

    // Write — override with default @Transactional
    @Transactional(rollbackFor = InsufficientStockException.class)
    public Order placeOrder(OrderRequest request) {
        Product product = productRepository.findById(request.getProductId())
            .orElseThrow(() -> new EntityNotFoundException("Product not found"));

        if (product.getStockQuantity() < request.getQuantity()) {
            throw new InsufficientStockException("Not enough stock");
        }

        product.setStockQuantity(product.getStockQuantity() - request.getQuantity());

        Order order = new Order();
        order.setCustomerId(request.getCustomerId());
        order.setProduct(product);
        order.setQuantity(request.getQuantity());
        order.setStatus(OrderStatus.PENDING);

        Order saved = orderRepository.save(order);

        // Audit in a separate transaction — commits even if outer tx rolls back
        auditService.logOrderPlaced(saved.getId()); // REQUIRES_NEW

        return saved;
    }

    @Transactional
    public void cancelOrder(Long orderId) {
        Order order = orderRepository.findById(orderId)
            .orElseThrow(() -> new EntityNotFoundException("Order not found"));

        if (order.getStatus() == OrderStatus.SHIPPED) {
            throw new IllegalStateException("Cannot cancel shipped order");
        }

        order.setStatus(OrderStatus.CANCELLED);
        // product stock restored via domain logic...
    }
}