Spring Boot 대용량 트랜잭션 전파 규칙 완전 정복

@Service
public class PaymentService {

    @Transactional
    public void outer() {
        // ...
        inner(); // 같은 클래스 내부 호출: 프록시 미경유, 트랜잭션 어노테이션 무시될 수 있음
    }

    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void inner() {
        // 기대: 새 트랜잭션
        // 현실: 적용 안 될 수 있음
    }
}

@Service
public class SettlementService {

    @Transactional // REQUIRED
    public void settleAll(List<Long> orderIds) {
        for (Long orderId : orderIds) {
            // 주문 정산 업데이트
            updateSettlement(orderId);

            // 외부 시스템 알림(HTTP)
            notifyExternal(orderId);

            // 이벤트 발행
            publishEvent(orderId);
        }
    }

    @Transactional // REQUIRED로 상위에 합류
    public void updateSettlement(Long orderId) {
        // JPA update
    }

    public void notifyExternal(Long orderId) {
        // HTTP call
    }

    public void publishEvent(Long orderId) {
        // Kafka send
    }
}

@Service
public class BulkJobService {

    private final ItemProcessor processor;
    private final JobLogService jobLogService;

    public BulkJobService(ItemProcessor processor, JobLogService jobLogService) {
        this.processor = processor;
        this.jobLogService = jobLogService;
    }

    public void run(List<Long> itemIds) {
        for (Long id : itemIds) {
            try {
                processor.processOne(id); // 아이템 단위 트랜잭션
            } catch (Exception e) {
                jobLogService.writeFailLog(id, e.getMessage()); // 실패 로그는 별도 트랜잭션
            }
        }
    }
}

@Service
class ItemProcessor {

    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void processOne(Long id) {
        // 1건 처리, 여기서만 원자성 보장
        // 실패하면 이 1건만 롤백
    }
}

@Service
class JobLogService {

    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void writeFailLog(Long id, String reason) {
        // 실패 로그는 반드시 커밋
    }
}

@Service
public class OrderService {

    private final ExternalClient externalClient;

    public OrderService(ExternalClient externalClient) {
        this.externalClient = externalClient;
    }

    @Transactional
    public void placeOrder(Long orderId) {
        // DB 저장은 트랜잭션 안
        saveOrder(orderId);

        // 외부 호출은 트랜잭션 밖에서
        callExternalWithoutTx(orderId);
    }

    @Transactional(propagation = Propagation.NOT_SUPPORTED)
    public void callExternalWithoutTx(Long orderId) {
        externalClient.notify(orderId);
    }

    private void saveOrder(Long orderId) {
        // repository.save
    }
}

@Service
public class MultiStepService {

    @Transactional
    public void runAll() {
        step1();

        try {
            step2Nested();
        } catch (RuntimeException e) {
            // step2만 롤백하고 step1은 유지한 채로 계속 진행하고 싶을 때
        }

        step3();
    }

    public void step1() {
        // ...
    }

    @Transactional(propagation = Propagation.NESTED)
    public void step2Nested() {
        // 실패하면 세이브포인트까지 롤백
        throw new RuntimeException("fail");
    }

    public void step3() {
        // ...
    }
}

@Service
public class StrictRepositoryFacade {

    @Transactional(propagation = Propagation.MANDATORY)
    public void mustBeInTxWrite() {
        // 트랜잭션 없이 호출되면 즉시 예외
    }

    @Transactional(propagation = Propagation.NEVER)
    public void mustNotBeInTx() {
        // 트랜잭션이 열려 있으면 즉시 예외
    }
}

@Transactional
public void doWork() throws Exception {
    // ...
    throw new Exception("checked"); // 기본 설정이면 롤백 안 될 수 있음
}

@Transactional(rollbackFor = Exception.class)
public void doWork() throws Exception {
    throw new Exception("checked");
}

@Service
public class ChunkedBulkService {

    private final ChunkWorker chunkWorker;

    public ChunkedBulkService(ChunkWorker chunkWorker) {
        this.chunkWorker = chunkWorker;
    }

    public void run(List<Long> ids, int chunkSize) {
        for (int i = 0; i < ids.size(); i += chunkSize) {
            List<Long> chunk = ids.subList(i, Math.min(ids.size(), i + chunkSize));
            chunkWorker.processChunk(chunk);
        }
    }
}

@Service
class ChunkWorker {

    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void processChunk(List<Long> chunk) {
        for (Long id : chunk) {
            // 업데이트
        }
    }
}

@Entity
class OutboxEvent {
    @Id @GeneratedValue
    private Long id;
    private String eventType;
    private String payload;
    private boolean published;
}

@Service
public class OrderTxService {

    private final OutboxRepository outboxRepository;

    public OrderTxService(OutboxRepository outboxRepository) {
        this.outboxRepository = outboxRepository;
    }

    @Transactional
    public void placeOrderWithOutbox(Long orderId) {
        // 주문 저장
        // ...

        // 같은 트랜잭션에 outbox 기록
        outboxRepository.save(new OutboxEvent(/*...*/));
    }
}