Devops Monk

@Entity
public class Order {
    @OneToMany(mappedBy = "order", fetch = FetchType.LAZY)
    private List<OrderItem> items; // lazy by default
}

@Service
public class OrderService {
    @Transactional(readOnly = true)
    public Order findOrder(Long id) {
        return orderRepository.findById(id).orElseThrow();
    } // ← transaction CLOSES here, persistence context gone
}

@RestController
public class OrderController {
    public OrderDto getOrder(@PathVariable Long id) {
        Order order = orderService.findOrder(id);
        // Transaction closed! Persistence context gone!
        order.getItems().size(); // ← LazyInitializationException
    }
}

@Transactional(readOnly = true)
public Order findOrderWithItems(Long id) {
    Order order = orderRepository.findById(id).orElseThrow();
    Hibernate.initialize(order.getItems()); // force-load inside tx
    return order;
}

@Query("SELECT o FROM Order o JOIN FETCH o.items WHERE o.id = :id")
Optional<Order> findWithItems(@Param("id") Long id);

@Transactional(readOnly = true)
public OrderDto findOrder(Long id) {
    Order order = orderRepository.findWithItems(id).orElseThrow();
    return OrderDto.from(order); // access lazy fields here, still in tx
}

# application.properties — Spring Boot default
spring.jpa.open-in-view=true  # ← this is the default

spring.jpa.open-in-view=false

@Service
// No @Transactional here
public class BadOrderService {

    public void processOrder(Long orderId) {
        Order order = orderRepository.findById(orderId).orElseThrow();
        // Transaction from findById is already closed here
        // order is now a DETACHED entity

        order.setStatus(OrderStatus.PROCESSING);
        orderRepository.save(order); // opens another transaction for save
        // but changes between these two calls are in a detached entity
    }
}

@Service
@Transactional
public class OrderService {

    public void processOrder(Long orderId) {
        Order order = orderRepository.findById(orderId).orElseThrow();
        // order is MANAGED — persistence context is tracking it
        order.setStatus(OrderStatus.PROCESSING);
        // No explicit save needed — dirty checking will persist the change
    }
}

// No @Transactional
public void updateProductName(Long id, String name) {
    Product p = productRepository.findById(id).orElseThrow(); // detached after this
    p.setName(name);
    // Nothing persists this change! No transaction, no flush.
    // The name change is silently lost.
}

@Transactional
public void createOrder(OrderRequest req) {
    try {
        orderRepository.save(buildOrder(req));
        inventoryService.deduct(req.getProductId(), req.getQuantity()); // may throw
    } catch (Exception e) {
        log.error("Error creating order", e); // swallow the exception
        // Transaction is NOT rolled back — it commits with partial data!
    }
}

@Transactional
public void createOrder(OrderRequest req) {
    try {
        orderRepository.save(buildOrder(req));
        inventoryService.deduct(req.getProductId(), req.getQuantity());
    } catch (InsufficientStockException e) {
        log.warn("Stock issue for order", e);
        throw e; // re-throw to trigger rollback
    }
}

catch (Exception e) {
    TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
    log.error("Marking transaction for rollback", e);
}

@Transactional
public void processAllOrders() {
    List<Order> allOrders = orderRepository.findAll(); // may be millions
    for (Order order : allOrders) {
        sendEmailNotification(order); // slow HTTP call inside transaction
        order.setNotificationSent(true);
    }
    // Transaction may be open for minutes — holding a connection
}

@Transactional(readOnly = true)
public List<Long> findUnnotifiedOrderIds() {
    return orderRepository.findUnnotifiedOrderIds();
}

@Transactional
public void markNotified(Long orderId) {
    orderRepository.findById(orderId).ifPresent(o -> o.setNotificationSent(true));
}

// In a scheduler or batch job:
public void processNotifications() {
    List<Long> ids = findUnnotifiedOrderIds(); // short tx
    for (Long id : ids) {
        emailService.send(id);          // no tx, may be slow
        markNotified(id);               // short tx per order
    }
}

@Transactional
public void reserveProduct(Long productId, int quantity) {
    try {
        inventoryService.reserve(productId, quantity);
    } catch (ConcurrencyFailureException e) {
        // OptimisticLock exception — we want to retry, not rollback
        throw e; // but throwing it WILL cause rollback
    }
}

@Transactional(noRollbackFor = ConcurrencyFailureException.class)
public void reserveProduct(Long productId, int quantity) {
    // If ConcurrencyFailureException fires, transaction still commits
    inventoryService.reserve(productId, quantity);
}

@Service
public class ParentService {
    @Transactional
    public void parent() {
        doWork();
        childService.child(); // REQUIRED — joins the same tx
    }
}

@Service
public class ChildService {
    @Transactional // REQUIRED — joins parent tx
    public void child() {
        // If this throws, the ENTIRE transaction (parent + child) rolls back
        throw new RuntimeException();
    }
}

@Transactional
public void parent() {
    doWork();
    try {
        childService.child(); // throws RuntimeException
    } catch (RuntimeException e) {
        log.error("child failed, continuing...");
        // WRONG: the transaction is ALREADY marked for rollback
        // Committing it will throw UnexpectedRollbackException
    }
}

@Transactional(propagation = Propagation.REQUIRES_NEW)
public void child() {
    // separate transaction — rolls back independently
    throw new RuntimeException();
}