@Transactional & Spring AOP

@Service
@RequiredArgsConstructor
@Transactional(readOnly = true)  // Default: read-only cho toàn class
@Slf4j
public class OrderService {
 
   private final OrderRepository orderRepository;
   private final InventoryService inventoryService;
   private final PaymentService paymentService;
   private final ApplicationEventPublisher eventPublisher;
 
   // Read-only: Hibernate skip dirty checking → faster
   public OrderDTO getById(UUID id) {
       return orderRepository.findById(id)
           .map(this::toDTO)
           .orElseThrow(() -> new OrderNotFoundException(id));
   }
 
   // Write operation: override class-level readOnly
   @Transactional  // readOnly = false
   public OrderDTO create(CreateOrderRequest request) {
       // Tất cả trong 1 transaction:
       Order order = buildOrder(request);
       order = orderRepository.save(order);          // 1. Save order
       inventoryService.reserve(order.getItems());   // 2. Reserve inventory
       paymentService.authorize(order);              // 3. Authorize payment
 
       // Nếu step 3 throw exception → phần ghi DB của step 1, 2 đều rollback
       // (gọi API bên ngoài thì không rollback được, phải tự bù trừ)
       eventPublisher.publishEvent(new OrderCreatedEvent(order));
       return toDTO(order);
   }
 
   // Explicit rollback rules
   @Transactional(rollbackFor = Exception.class)  // Rollback cho checked exceptions
   public void importOrders(List<CreateOrderRequest> requests) {
       // Mặc định: chỉ rollback RuntimeException + Error
       // rollbackFor = Exception.class: rollback cả checked exceptions
       requests.forEach(this::create);
   }
 
   // No rollback cho specific exceptions
   @Transactional(noRollbackFor = DuplicateOrderException.class)
   public OrderDTO createIdempotent(CreateOrderRequest request) {
       try {
           return create(request);
       } catch (DuplicateOrderException e) {
           // Exception đã bị catch nên rollback rule không dính vào;
           // noRollbackFor chỉ có tác dụng khi exception ném RA KHỎI method
           return getByIdempotencyKey(request.getIdempotencyKey());
       }
   }
}

@Service
public class OrderService {
 
   // REQUIRED (default): Join TX hiện có, hoặc tạo mới
   @Transactional(propagation = Propagation.REQUIRED)
   public OrderDTO create(CreateOrderRequest request) {
       // Nếu caller đã có TX → join
       // Nếu không → tạo TX mới
   }
 
   // REQUIRES_NEW: LUÔN tạo TX mới (suspend TX hiện tại)
   @Transactional(propagation = Propagation.REQUIRES_NEW)
   public void logAudit(AuditEntry entry) {
       // TX riêng: commit ngay cả khi caller TX rollback
       // Lưu ý: TX ngoài vẫn giữ connection, TX mới lấy thêm 1 connection nữa
       // Use case: audit log phải ghi bất kể business op thành công hay không
       auditRepository.save(entry);
   }
 
   // NESTED: Tạo savepoint trong TX hiện tại
   @Transactional(propagation = Propagation.NESTED)
   public void processItem(OrderItem item) {
       // Nếu fail → rollback đến savepoint (không rollback cả TX)
       // Caller có thể catch và continue với item tiếp
       // Chỉ đúng với JDBC; với JPA, savepoint không rollback entity trong persistence context
   }
 
   // MANDATORY: PHẢI có TX sẵn, exception nếu không
   @Transactional(propagation = Propagation.MANDATORY)
   public void updateInventory(UUID productId, int qty) {
       // Force caller phải gọi trong TX context
       // Tránh vô tình gọi standalone mà quên TX
   }
 
   // NOT_SUPPORTED: Suspend TX, chạy không TX
   @Transactional(propagation = Propagation.NOT_SUPPORTED)
   public ReportDTO generateReport(ReportRequest request) {
       // Read-heavy, long-running → không cần giữ TX lock
   }
}

// READ_COMMITTED (default PostgreSQL): Không đọc uncommitted data
@Transactional(isolation = Isolation.READ_COMMITTED)
public OrderDTO getOrder(UUID id) { ... }
 
// REPEATABLE_READ: Cùng query trong TX luôn trả cùng kết quả
@Transactional(isolation = Isolation.REPEATABLE_READ)
public void transferFunds(UUID from, UUID to, BigDecimal amount) {
   // Snapshot đọc không đổi, nhưng KHÔNG tự khoá dòng:
   // PostgreSQL: TX ghi sau bị lỗi serialization → phải retry
   // MySQL InnoDB: UPDATE đọc giá trị mới nhất → vẫn có thể lost update
   // Muốn chắc: SELECT ... FOR UPDATE hoặc optimistic lock (@Version)
}
 
// SERIALIZABLE: Cao nhất — kết quả như thể các TX chạy tuần tự
@Transactional(isolation = Isolation.SERIALIZABLE)
public void processPayment(PaymentRequest request) {
   // DB không thật sự chạy tuần tự: PostgreSQL (SSI) cho chạy song song
   // rồi huỷ TX xung đột → caller phải retry khi gặp serialization failure
   // Trade-off: throughput giảm, tỉ lệ retry tăng khi tranh chấp cao
}

// ❌ PITFALL 1: Self-invocation bypass proxy
@Service
public class OrderService {
   @Transactional
   public void processAll() {
       for (Order order : orders) {
           this.processOne(order); // GỌI TRỰC TIẾP → KHÔNG qua proxy → KHÔNG có TX
       }
   }
 
   @Transactional(propagation = Propagation.REQUIRES_NEW)
   public void processOne(Order order) { ... }
}
 
// ✅ FIX: Inject self hoặc tách service
@Service
@RequiredArgsConstructor
public class OrderService {
   private final OrderItemProcessor itemProcessor; // Separate bean
 
   @Transactional
   public void processAll() {
       for (Order order : orders) {
           itemProcessor.processOne(order); // Qua proxy → có TX
       }
   }
}
 
// ❌ PITFALL 2: @Transactional trên private/final method
@Transactional
private void internalMethod() { }  // CGLIB cannot proxy private/final
 
// ❌ PITFALL 3: Catch exception trong TX method
@Transactional
public void riskyOperation() {
   try {
       otherService.riskyCall(); // @Transactional (REQUIRED) ở bean khác, throws RuntimeException
   } catch (Exception e) {
       log.error("Failed", e);
       // Exception đã đi qua proxy của riskyCall → TX chung bị mark rollback-only!
       // Khi method return, Spring throw UnexpectedRollbackException
   }
}
 
// ✅ FIX: REQUIRES_NEW cho từng item (hoặc TransactionTemplate) khi cần partial commit
@Transactional
public void batchProcess(List<Item> items) {
   for (Item item : items) {
       try {
           itemProcessor.process(item); // REQUIRES_NEW → isolated TX
       } catch (Exception e) {
           log.warn("Item {} failed, continuing", item.getId());
           // item's TX rolls back, outer TX continues
       }
   }
}

@Aspect
@Component
@Slf4j
public class ServiceLoggingAspect {
 
   // Pointcut: mọi public method trong package service
   @Around("execution(public * com.tungdadev.csp..service..*(..))")
   public Object logServiceMethod(ProceedingJoinPoint joinPoint) throws Throwable {
       String method = joinPoint.getSignature().toShortString();
       String traceId = RequestContext.getRequestId();
       long start = System.nanoTime();
 
       log.info("[traceId={}] → {}", traceId, method);
       try {
           Object result = joinPoint.proceed();
           long duration = (System.nanoTime() - start) / 1_000_000;
           log.info("[traceId={}] ← {} | {}ms", traceId, method, duration);
           return result;
       } catch (Exception e) {
           long duration = (System.nanoTime() - start) / 1_000_000;
           log.error("[traceId={}] ✗ {} | {}ms | {}", traceId, method, duration, e.getMessage());
           throw e;
       }
   }
}

@Aspect
@Component
@Slf4j
@RequiredArgsConstructor
public class PerformanceAspect {
 
   private final MeterRegistry meterRegistry;
 
   // Custom annotation
   @Around("@annotation(monitored)")
   public Object monitorPerformance(ProceedingJoinPoint pjp, Monitored monitored) throws Throwable {
       String metricName = monitored.value().isEmpty()
           ? pjp.getSignature().toShortString()
           : monitored.value();
 
       Timer.Sample sample = Timer.start(meterRegistry);
       try {
           Object result = pjp.proceed();
           sample.stop(Timer.builder(metricName).tag("status", "success").register(meterRegistry));
           return result;
       } catch (Exception e) {
           sample.stop(Timer.builder(metricName).tag("status", "error").register(meterRegistry));
           throw e;
       }
   }
}
 
// Custom annotation
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Monitored {
   String value() default "";
}
 
// Usage
@Monitored("order.creation")
public OrderDTO createOrder(CreateOrderRequest request) { ... }

@Aspect
@Component
@Slf4j
public class RetryAspect {
 
   @Around("@annotation(retryable)")
   public Object retry(ProceedingJoinPoint pjp, Retryable retryable) throws Throwable {
       int maxAttempts = retryable.maxAttempts();
       long delay = retryable.delay();
       Exception lastException = null;
 
       for (int attempt = 1; attempt <= maxAttempts; attempt++) {
           try {
               return pjp.proceed();
           } catch (Exception e) {
               lastException = e;
               if (attempt < maxAttempts) {
                   log.warn("Attempt {}/{} failed for {}: {}. Retrying in {}ms",
                       attempt, maxAttempts, pjp.getSignature().toShortString(),
                       e.getMessage(), delay);
                   Thread.sleep(delay);
                   delay *= 2; // Exponential backoff
               }
           }
       }
       throw lastException;
   }
}
 
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Retryable {
   int maxAttempts() default 3;
   long delay() default 1000;
}
 
// Usage
@Retryable(maxAttempts = 3, delay = 500)
public ExternalResponse callExternalService(Request request) { ... }

// Mọi method trong service package
@Pointcut("execution(* com.tungdadev.csp..service..*(..))")
 
// Mọi public method
@Pointcut("execution(public * *(..))")
 
// Method có annotation cụ thể
@Pointcut("@annotation(com.tungdadev.csp.common.annotation.Monitored)")
 
// Class có annotation cụ thể
@Pointcut("@within(org.springframework.stereotype.Service)")
 
// Method nhận tham số cụ thể (phải ghi tên class đầy đủ, trừ java.lang)
@Pointcut("execution(* *..*(java.util.UUID, ..))")  // First param is UUID
 
// Combine pointcuts (serviceLayer() và getter() là 2 method @Pointcut khai báo trước)
@Pointcut("serviceLayer() && !getter()")
public void serviceMethodsExcludeGetters() {}