ApplicationEvent — 객체 간 결합을 끊는 이벤트 기반 설계

@Service
@RequiredArgsConstructor
public class OrderService {
    private final OrderRepository orderRepository;
    private final EmailService emailService;         // 결합
    private final PointService pointService;         // 결합
    private final InventoryService inventoryService; // 결합
    private final AnalyticsService analyticsService;  // 결합

    @Transactional
    public void completeOrder(Order order) {
        orderRepository.save(order);

        emailService.sendOrderConfirmation(order);    // 이메일 실패하면?
        pointService.addPoints(order.getUserId(), 100); // 포인트 서비스 장애면?
        inventoryService.decrease(order.getProductId()); // 재고 서비스 추가되면?
        analyticsService.trackOrder(order);             // 또 다른 서비스가 추가되면?
    }
}

1. 발행자가 ApplicationEventPublisher.publishEvent(event) 호출
2. ApplicationEventMulticaster가 등록된 리스너를 검색
3. 이벤트 타입에 맞는 리스너를 찾아 호출
4. 기본적으로 동기 실행 (같은 스레드)

// 이벤트 객체 (단순 POJO)
public record OrderCompletedEvent(
    Long orderId,
    Long userId,
    Long productId,
    int amount
) {}

@Service
@RequiredArgsConstructor
public class OrderService {
    private final OrderRepository orderRepository;
    private final ApplicationEventPublisher eventPublisher;

    @Transactional
    public void completeOrder(Order order) {
        orderRepository.save(order);

        // 이벤트 발행 — 누가 듣는지 알 필요 없음
        eventPublisher.publishEvent(new OrderCompletedEvent(
            order.getId(), order.getUserId(),
            order.getProductId(), order.getAmount()
        ));
    }
}

@Component
@RequiredArgsConstructor
public class OrderEventListener {
    private final EmailService emailService;

    @EventListener
    public void handleOrderCompleted(OrderCompletedEvent event) {
        emailService.sendOrderConfirmation(event.orderId());
    }
}

@Component
@RequiredArgsConstructor
public class PointEventListener {
    private final PointService pointService;

    @EventListener
    public void handleOrderCompleted(OrderCompletedEvent event) {
        pointService.addPoints(event.userId(), 100);
    }
}

@Component
public class OrderEventListener {

    // 트랜잭션이 커밋된 후에 실행
    @TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)
    public void sendEmail(OrderCompletedEvent event) {
        // 주문이 확실히 저장된 후에 이메일 발송
        emailService.sendOrderConfirmation(event.orderId());
    }

    // 트랜잭션이 롤백된 후에 실행
    @TransactionalEventListener(phase = TransactionPhase.AFTER_ROLLBACK)
    public void handleRollback(OrderCompletedEvent event) {
        log.warn("주문 {} 롤백됨", event.orderId());
    }
}

@TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)
public void afterOrderCommit(OrderCompletedEvent event) {
    // 이 시점에서는 이미 트랜잭션이 커밋된 후!
    // 여기서 DB 쓰기를 하려면 새 트랜잭션이 필요
    // pointRepository.save(...); ← TransactionRequiredException!
}

// 해결: 새 트랜잭션으로 실행
@TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)
@Transactional(propagation = Propagation.REQUIRES_NEW)
public void afterOrderCommit(OrderCompletedEvent event) {
    pointRepository.save(new Point(event.userId(), 100)); // 새 트랜잭션에서 실행
}

@Configuration
@EnableAsync
public class AsyncConfig {
    @Bean
    public TaskExecutor eventTaskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(5);
        executor.setMaxPoolSize(10);
        executor.setQueueCapacity(100);
        executor.setThreadNamePrefix("event-");
        return executor;
    }
}

@Component
public class NotificationListener {

    @Async("eventTaskExecutor")
    @EventListener
    public void sendPushNotification(OrderCompletedEvent event) {
        // 별도 스레드에서 실행 → 주문 응답 지연 없음
        pushService.send(event.userId(), "주문 완료!");
    }
}

@Component
public class PointEventListener {

    @EventListener
    public PointEarnedEvent handleOrderCompleted(OrderCompletedEvent event) {
        // 포인트 적립
        pointService.addPoints(event.userId(), 100);

        // 반환값이 이벤트 객체면 자동으로 발행됨
        return new PointEarnedEvent(event.userId(), 100);
    }
}

@Component
public class BadgeListener {

    @EventListener
    public void handlePointEarned(PointEarnedEvent event) {
        // 포인트 적립 이벤트를 받아서 뱃지 확인
        badgeService.checkAndAward(event.userId());
    }
}

@Component
public class VIPOrderListener {

    @EventListener(condition = "#event.amount >= 100000")
    public void handleHighValueOrder(OrderCompletedEvent event) {
        // 10만원 이상 주문에만 반응
        vipService.upgrade(event.userId());
    }
}

@Component
public class OrderEventListeners {

    @EventListener
    @Order(1)
    public void validateFirst(OrderCompletedEvent event) {
        // 먼저 실행
    }

    @EventListener
    @Order(2)
    public void processSecond(OrderCompletedEvent event) {
        // 나중 실행
    }
}