트랜잭션과 예외 — 왜 RuntimeException에서만 롤백될까

@Transactional
public void process() {
    // ✓ 롤백되는 예외
    throw new RuntimeException();          // 언체크 예외
    throw new IllegalArgumentException();  // RuntimeException 하위
    throw new NullPointerException();      // RuntimeException 하위
    throw new OutOfMemoryError();          // Error

    // ✗ 롤백되지 않는 예외 (커밋됨!)
    throw new IOException();               // 체크 예외
    throw new SQLException();              // 체크 예외
    throw new Exception();                 // 체크 예외
}

// 모든 예외에서 롤백
@Transactional(rollbackFor = Exception.class)
public void process() throws Exception {
    // IOException, SQLException 등 체크 예외에서도 롤백됨
}

// 특정 체크 예외에서만 롤백
@Transactional(rollbackFor = {IOException.class, CustomCheckedException.class})
public void process() throws IOException {
    // IOException → 롤백
    // 다른 체크 예외 → 커밋
}

// 특정 런타임 예외에서는 롤백하지 않음
@Transactional(noRollbackFor = NotificationFailedException.class)
public void createOrder(OrderRequest request) {
    orderRepository.save(new Order(request));

    try {
        notificationService.sendNotification(request.getUserId());
    } catch (NotificationFailedException e) {
        // 알림 실패는 주문에 영향을 주지 않음 → 커밋
        log.warn("알림 전송 실패", e);
        throw e;  // noRollbackFor에 의해 커밋됨
    }
}

@Transactional
public void process() {
    try {
        riskyOperation();  // RuntimeException 발생 가능
    } catch (RuntimeException e) {
        log.error("에러 발생", e);
        // 예외를 잡았으므로 프록시에 전달되지 않음 → 커밋됨
    }
    // 이후 로직 계속 실행 → 트랜잭션 커밋
}

@Transactional
public void process() {
    try {
        riskyOperation();
    } catch (RuntimeException e) {
        log.error("에러 발생, 롤백 예정", e);
        throw e;  // 다시 던지면 프록시가 받아서 롤백
    }
}

@Service
public class OuterService {

    @Transactional
    public void outer() {
        try {
            innerService.inner();  // REQUIRED — 같은 트랜잭션 참여
        } catch (RuntimeException e) {
            // 예외를 잡아도 이미 rollback-only 마크 설정됨!
            log.error("inner 실패", e);
        }
        // 커밋 시도 → UnexpectedRollbackException 발생!
    }
}

@Service
public class InnerService {

    @Transactional  // REQUIRED (기본)
    public void inner() {
        throw new RuntimeException("실패");
        // → 같은 물리 트랜잭션에 rollback-only 마크 설정
    }
}

@Transactional
public void processFile(MultipartFile file) {
    try {
        fileService.save(file);  // IOException 가능
    } catch (IOException e) {
        // 체크 예외 → 런타임 예외 변환 → 롤백됨
        throw new FileProcessingException("파일 저장 실패", e);
    }
}

// 커스텀 런타임 예외
public class FileProcessingException extends RuntimeException {
    public FileProcessingException(String message, Throwable cause) {
        super(message, cause);
    }
}

// 비즈니스 예외 — 롤백이 필요한 경우 RuntimeException 상속
public class InsufficientBalanceException extends RuntimeException {
    public InsufficientBalanceException(String message) {
        super(message);
    }
}

// 비즈니스 예외 — 롤백이 불필요한 경우
public class DuplicateNicknameException extends RuntimeException {
    // noRollbackFor로 설정하거나, try-catch로 처리
}

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

    // 조회 — readOnly
    public OrderDto getOrder(Long id) {
        return orderRepository.findById(id)
            .map(OrderDto::from)
            .orElseThrow(() -> new OrderNotFoundException(id));
    }

    // 변경 — rollbackFor 명시
    @Transactional(rollbackFor = Exception.class)
    public OrderDto createOrder(OrderCreateRequest request) {
        // 모든 예외에서 롤백하도록 설정
        Order order = Order.create(request);
        orderRepository.save(order);
        return OrderDto.from(order);
    }
}