import 문을 줄이는 가장 우아한 방법 (feat: ApplicationEvent)

"사용자 데이터 저장해."
"상품 재고 수정해."

"사용자 가입이 완료되었다."
"주문이 생성되었다."

// 강한 결합의 증거, import 문들
import com.example.coupon.CouponService;
import com.example.notification.EmailService;
import com.example.stock.StockService;

@Service
public class OrderService {
    private final CouponService couponService;
    private final EmailService emailService;
    private final StockService stockService;

    public void placeOrder(...) {
        // 주문 처리 로직 ...
        couponService.use(...); // 쿠폰 서비스에 직접 명령
        emailService.sendOrderCompleted(...); // 이메일 서비스에 직접 명령
        stockService.deduct(...); // 재고 서비스에 직접 명령
    }
}

[주문 생성 서비스]
   └── (이벤트 발행) → [쿠폰 처리 서비스], [재고 처리 서비스] , [이메일 알림 서비스] …

// import com.example.coupon.CouponService;        // <-- 사라짐
// import com.example.notification.EmailService;  // <-- 사라짐
// import com.example.stock.StockService;         // <-- 사라짐

@Service
public class OrderService {
    private final ApplicationEventPublisher publisher; // 오직 '발행자'만 안다.

    public void place(...) {
        // 주문 처리 로직 ...
        publisher.publishEvent(new OrderEvent.Complete(...)); // "주문 완료됐다!" 방송만 한다.
    }
}

// OrderFacade.java
@Transactional
public OrderResult.Create place(OrderCriteria orderCriteria) {
    // ...
    // 1. 쿠폰으로 할인 금액을 '계산'하고,
    // 2. 쿠폰 상태를 '사용됨'으로 변경
    Long discountAmount = couponService.getDiscountAmount(orderCriteria.getCouponId(), ...);
    // 3. 할인 금액을 포함하여 주문을 '생성'
    OrderCommand command = OrderCommandMapper.map(..., discountAmount);
    return OrderResult.Create.from(orderService.place(command));
}

// PointPaymentProcessor.java
@Override
@Transactional
public void pay(PaymentProcessContext context) {
    // 1. 핵심 트랜잭션: 포인트 차감
    pointService.deduct(context.getUserId(), order.getFinalAmount());

    // --- 여기서부터 명백한 후속 트랜잭션들 ---
    // 2. 후속 처리 1: 결제 상태 '완료'로 변경
    // 3. 후속 처리 2: 상품 재고 차감
    // 4. 후속 처리 3: 주문 상태 '결제 완료'로 변경
}

// 개선된 PointPaymentProcessor.java
@Override
@Transactional
public void pay(PaymentProcessContext context) {
    // 1. 핵심 책임만 수행한다.
    pointService.deduct(context.getUserId(), ...);
    // 2. "결제 성공했다!"는 사실만 방송한다.
    applicationEventPublisher.publishEvent(PaymentEvent.Success.of(order.getId(), ...));
}

@Service
@RequiredArgsConstructor
public class OuterService {
    private final PointRepository pointRepository;
    private final ApplicationEventPublisher applicationEventPublisher;

    @Transactional
    public void charge(Long userId, Long balance) {
        Point point = new Point(userId, balance);
        Point savedPoint = pointRepository.save(point);
        applicationEventPublisher.publishEvent(new OuterEvent(savedPoint.getId(), userId, balance));
    }
}

@Service
@Slf4j
@RequiredArgsConstructor
public class InnerService {
    private final PointHistoryRepository pointHistoryRepository;

    @EventListener
    public void handle(OuterEvent event) {
        log.info("이벤트 컨슘: pointId={}", event.getPointId());
        pointHistoryRepository.save(new PointHistory("CREATE"));
        throw new IllegalArgumentException("에러 발생"); // 의도적으로 예외 발생
    }
}

@SpringBootTest
class EventListenerRollbackTest {

    @Autowired OuterService outerService;
    @Autowired PointRepository pointRepository;

    @Test
    @DisplayName("@EventListener 에서 예외 발생 시, 발행자의 트랜잭션도 롤백된다")
    void eventListener_throwsException_thenRollback() {
        // when & then
        assertThatThrownBy(() -> outerService.charge(1L, 1000L))
                .isInstanceOf(IllegalArgumentException.class);

        // then
        assertThat(pointRepository.count()).isZero();
    }
}

// 1. OuterService.charge()를 위한 새로운 트랜잭션 생성
...jpaTransactionManager : Creating new transaction with name [...OuterService.charge]...
...TransactionInterceptor    : Getting transaction for [...OuterService.charge]

// 2. PointRepository.save() 실행 (아직 커밋 전)
DEBUG ... org.hibernate.SQL                 : insert into point (balance, user_id) values (?, ?)

// 3. InnerService.handle() 이벤트 리스너 실행
//    별도의 트랜잭션 로그 없이, 기존 트랜잭션에 참여하는 것을 볼 수 있음
...JpaTransactionManager : Participating in existing transaction
...InnerService   : 이벤트 컨슘1: pointId=1
DEBUG ... org.hibernate.SQL                 : insert into point_history (type) values (?)

// 4. InnerService에서 예외 발생 후, OuterService의 트랜잭션이 롤백됨!
...: Completing transaction for [...OuterService.charge] after exception: java.lang.IllegalArgumentException
...JpaTransactionManager : Initiating transaction rollback
...JpaTransactionManager : Rolling back JPA transaction on EntityManager [...]

// InnerService.java
@TransactionalEventListener(phase = TransactionPhase.BEFORE_COMMIT)
public void handle(OuterEvent event) {
    log.info("이벤트 컨슘1: pointId={}", event.getPointId());
    pointHistoryRepository.save(new PointHistory("CREATE"));
    throw new IllegalArgumentException("에러 발생");
}

// 테스트 코드
@Test
@DisplayName("@TransactionalEventListener(BEFORE_COMMIT) 에서 예외 발생 시, 발행자의 트랜잭션도 롤백된다")
void beforeCommitListener_throwsException_thenRollback() {
    // when & then
    assertThatThrownBy(() -> outerService.charge(1L, 1000L))
            .isInstanceOf(IllegalArgumentException.class);

    // then
    assertThat(pointRepository.count()).isZero();
}

// 1. OuterService.charge()를 위한 새로운 트랜잭션 생성
...JpaTransactionManager : Creating new transaction with name [...OuterService.charge]...

// 2. PointRepository.save() 실행 (아직 커밋 전)
DEBUG ... org.hibernate.SQL                 : insert into point (balance, user_id) values (?, ?)

// 3. OuterService.charge() 메소드 종료 -> 트랜잭션 커밋 시도
...TransactionInterceptor    : Completing transaction for [...OuterService.charge]

// 4. '커밋 직전'에 이벤트 리스너 실행!
INFO  ... s.s.t.domain.inner.InnerService   : 이벤트 컨슘1: pointId=1
DEBUG ... org.hibernate.SQL                 : insert into point_history (type) values (?)

// 5. InnerService에서 예외 발생 후, '커밋 과정에서 예외가 발생'했으므로 롤백됨
..JpaTransactionManager : Initiating transaction rollback after commit exception
...JpaTransactionManager : Rolling back JPA transaction on EntityManager [...]

// @EventListener의 실행 흐름
[TX 시작] -> charge() 로직 1 -> save()
-> publishEvent() -> [**handle() 즉시 실행**]
-> charge() 로직 2 -> [TX 커밋/롤백]

// @TransactionalEventListener(BEFORE_COMMIT)의 실행 흐름
[TX 시작] -> charge() 로직 1 -> save()
-> publishEvent()
-> charge() 로직 2 -> [TX 커밋 시도] -> [**handle() 실행**] -> [실제 DB 커밋/롤백]

// InnerService.java
@TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)
public void handle(OuterEvent event) {
    log.info("이벤트 컨슘1: pointId={}", event.getPointId());
    pointHistoryRepository.save(new PointHistory("CREATE"));
    throw new IllegalArgumentException("에러 발생");
}

// 실패했던 최초의 테스트 코드
@Test
@DisplayName("AFTER_COMMIT 리스너에서 예외가 발생해도, 발행자는 커밋될 것이라 예상한다")
void afterCommitListener_throwsException_butPublisherIsCommitted() {
    // given & when & then
    // 리스너에서 발생한 예외가 여기까지 전파될 것이라 예상했지만...
    assertThatThrownBy(() -> outerService.charge(1L, 1000L))
            .isInstanceOf(IllegalArgumentException.class);

    // 리스너만 롤백되고, 발행자는 커밋되었을 테니 count는 1일 것이다.
    assertThat(pointRepository.count()).isEqualTo(1L);
}

// 성공한 최종 테스트 코드
@Test
@DisplayName("AFTER_COMMIT 리스너의 예외는 발행자에게 전파되지 않아 롤백시키지 않는다")
void afterCommitListener_exceptionDoesNotPropagate() {
    // when
    // 예외가 전파되지 않으므로, charge() 메소드는 정상 종료된다.
    outerService.charge(1L, 1000L);

    // then
    // 발행자의 트랜잭션은 성공적으로 커밋되었으므로, 데이터는 1건 존재해야 한다.
    assertThat(pointRepository.count()).isEqualTo(1L);
}

// 1. OuterService.charge()를 위한 트랜잭션 생성 및 실행
...

// 2. OuterService.charge()의 모든 로직이 끝나고, 트랜잭션 커밋!
TRACE ... o.s.t.i.TransactionInterceptor    : Completing transaction for [...OuterService.charge]
DEBUG ... o.s.orm.jpa.JpaTransactionManager : Initiating transaction commit
DEBUG ... o.s.orm.jpa.JpaTransactionManager : Committing JPA transaction on EntityManager [...]

// 3. --- 트랜잭션이 성공적으로 DB에 커밋된 후 ---
//    이제서야 리스너가 실행된다.
INFO  ... s.s.t.domain.inner.InnerService   : 이벤트 컨슘1: pointId=1

// 4. 리스너에서 예외가 발생했지만, 이미 트랜잭션은 끝났다.
...TransactionSynchronizationUtils  : TransactionSynchronization.afterCompletion threw exception
java.lang.IllegalArgumentException: 에러 발생