트랜잭션과 동시성

@Service
@RequiredArgsConstructor
public class OrderService {
    private final OrderRepository orderRepository;
    private final PaymentService paymentService;
    private final NotificationService notificationService;
    private final AuditLogService auditLogService;
    
    @Transactional
    public Long createOrder(CreateOrderCommand command) {
        Order order = Order.create(command);
        orderRepository.save(order);
        
        // 결제 처리 (같은 트랜잭션)
        paymentService.processPayment(order);
        
        // 알림은 별도 트랜잭션 (실패해도 주문은 유지)
        notificationService.sendOrderNotification(order);
        
        // 감사 로그는 항상 기록 (주문 실패해도)
        auditLogService.log("ORDER_CREATED", order.getId());
        
        return order.getId();
    }
}

@Service
public class NotificationService {
    
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void sendOrderNotification(Order order) {
        // 별도 트랜잭션: 실패해도 주문 트랜잭션에 영향 없음
        // 알림 실패 시 이 트랜잭션만 롤백
    }
}

@Service
public class AuditLogService {
    
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void log(String action, Long entityId) {
        // 항상 새 트랜잭션: 메인 트랜잭션 롤백되어도 로그는 남음
    }
}

@Entity
public class Product {
    @Id @GeneratedValue
    private Long id;
    
    private String name;
    private Integer stockQuantity;
    
    @Version  // 낙관적 락 - 수정 시 버전 자동 증가
    private Long version;
    
    public void decreaseStock(int quantity) {
        if (stockQuantity < quantity) {
            throw new IllegalStateException("재고 부족");
        }
        stockQuantity -= quantity;
    }
}

// 사용
@Transactional
public void orderProduct(Long productId, int quantity) {
    Product product = productRepository.findById(productId).orElseThrow();
    product.decreaseStock(quantity);
    // 커밋 시점에 version 체크
    // 다른 트랜잭션이 먼저 수정했으면 OptimisticLockException 발생
}

// 실행되는 SQL
// UPDATE products 
// SET stock_quantity = ?, version = version + 1 
// WHERE id = ? AND version = ?

// Spring Retry 사용
@Service
@RequiredArgsConstructor
public class ProductService {
    
    @Transactional
    @Retryable(
        value = OptimisticLockException.class,
        maxAttempts = 3,
        backoff = @Backoff(delay = 100)
    )
    public void decreaseStock(Long productId, int quantity) {
        Product product = productRepository.findById(productId)
            .orElseThrow();
        product.decreaseStock(quantity);
    }
    
    @Recover
    public void recoverFromOptimisticLock(OptimisticLockException e, 
                                           Long productId, int quantity) {
        log.error("재고 차감 실패 - 재시도 초과: productId={}", productId);
        throw new BusinessException("일시적인 오류가 발생했습니다. 다시 시도해주세요.");
    }
}

// 수동 재시도 구현
public void decreaseStockWithRetry(Long productId, int quantity) {
    int maxRetries = 3;
    for (int i = 0; i < maxRetries; i++) {
        try {
            decreaseStock(productId, quantity);
            return;
        } catch (OptimisticLockException e) {
            if (i == maxRetries - 1) throw e;
            Thread.sleep(100 * (i + 1));  // 백오프
        }
    }
}

public interface ProductRepository extends JpaRepository<Product, Long> {
    
    // 비관적 쓰기 락 (SELECT ... FOR UPDATE)
    @Lock(LockModeType.PESSIMISTIC_WRITE)
    @Query("SELECT p FROM Product p WHERE p.id = :id")
    Optional<Product> findByIdWithLock(@Param("id") Long id);
    
    // 비관적 읽기 락 (SELECT ... FOR SHARE)
    @Lock(LockModeType.PESSIMISTIC_READ)
    Optional<Product> findWithReadLockById(Long id);
    
    // 타임아웃 설정
    @Lock(LockModeType.PESSIMISTIC_WRITE)
    @QueryHints(@QueryHint(name = "javax.persistence.lock.timeout", value = "3000"))
    @Query("SELECT p FROM Product p WHERE p.id = :id")
    Optional<Product> findByIdWithLockTimeout(@Param("id") Long id);
}

// 사용
@Transactional
public void orderProductWithLock(Long productId, int quantity) {
    // 다른 트랜잭션은 이 행에 접근 불가 (대기)
    Product product = productRepository.findByIdWithLock(productId)
        .orElseThrow();
    product.decreaseStock(quantity);
}

// 실행되는 SQL
// SELECT * FROM products WHERE id = ? FOR UPDATE

@Service
@RequiredArgsConstructor
public class OrderService {
    private final ProductRepository productRepository;
    private final OrderRepository orderRepository;
    
    // 낙관적 락 + 재시도 (일반적인 주문)
    @Transactional
    @Retryable(value = OptimisticLockException.class, maxAttempts = 3)
    public Long createOrder(CreateOrderCommand command) {
        Order order = new Order();
        
        for (OrderItemRequest item : command.getItems()) {
            Product product = productRepository.findById(item.getProductId())
                .orElseThrow();
            product.decreaseStock(item.getQuantity());  // @Version 체크
            order.addOrderItem(OrderItem.create(product, item.getQuantity()));
        }
        
        orderRepository.save(order);
        return order.getId();
    }
    
    // 비관적 락 (선착순 이벤트, 재고 정확성 필수)
    @Transactional
    public Long createOrderWithLock(CreateOrderCommand command) {
        Order order = new Order();
        
        // 상품 ID 정렬하여 데드락 방지
        List<Long> sortedProductIds = command.getItems().stream()
            .map(OrderItemRequest::getProductId)
            .sorted()
            .collect(Collectors.toList());
        
        for (Long productId : sortedProductIds) {
            Product product = productRepository.findByIdWithLock(productId)
                .orElseThrow();
            
            int quantity = command.getItems().stream()
                .filter(i -> i.getProductId().equals(productId))
                .mapToInt(OrderItemRequest::getQuantity)
                .sum();
            
            product.decreaseStock(quantity);
            order.addOrderItem(OrderItem.create(product, quantity));
        }
        
        orderRepository.save(order);
        return order.getId();
    }
}

@Entity
public class CouponEvent {
    @Id @GeneratedValue
    private Long id;
    
    private String name;
    private Integer totalQuantity;
    private Integer issuedQuantity;
    
    @Version
    private Long version;
    
    public void issue() {
        if (issuedQuantity >= totalQuantity) {
            throw new CouponExhaustedException("쿠폰이 모두 소진되었습니다.");
        }
        issuedQuantity++;
    }
}

@Service
@RequiredArgsConstructor
public class CouponService {
    
    // 비관적 락 사용 (선착순이므로 정확성 필수)
    @Transactional
    public Long issueCoupon(Long eventId, Long memberId) {
        CouponEvent event = couponEventRepository.findByIdWithLock(eventId)
            .orElseThrow();
        
        // 중복 발급 체크
        if (couponRepository.existsByEventIdAndMemberId(eventId, memberId)) {
            throw new DuplicateCouponException("이미 발급받은 쿠폰입니다.");
        }
        
        event.issue();  // 수량 차감
        
        Coupon coupon = Coupon.create(event, memberId);
        couponRepository.save(coupon);
        
        return coupon.getId();
    }
}