Spring 4.2 이전의 이벤트 리스너 구현 방식:

public class UserRegistrationListener implements ApplicationListener<UserRegisteredEvent> {
    
    @Override
    public void onApplicationEvent(UserRegisteredEvent event) {
        // 이벤트 처리 로직
        User user = event.getUser();
        sendWelcomeEmail(user);
    }
    
    private void sendWelcomeEmail(User user) {
        // 이메일 발송 로직
    }
}

Spring 4.2 이후의 이벤트 리스너 구현 방식:

@Component
public class UserService {
    
    @EventListener
    public void handleUserRegistered(UserRegisteredEvent event) {
        // 이벤트 처리 로직
        User user = event.getUser();
        sendWelcomeEmail(user);
    }
    
    private void sendWelcomeEmail(User user) {
        // 이메일 발송 로직
    }
}

@Component
public class MyEventHandler {
    
    @EventListener
    public void handleMyEvent(MyCustomEvent event) {
        System.out.println("이벤트 수신: " + event.getMessage());
    }
}

@EventListener(condition = "#event.success == true")
public void handleSuccessfulEvent(MyCustomEvent event) {
    System.out.println("성공한 이벤트만 처리합니다!");
}

@EventListener(classes = { UserCreatedEvent.class, UserUpdatedEvent.class })
public void handleUserEvents(ApplicationEvent event) {
    if (event instanceof UserCreatedEvent) {
        UserCreatedEvent userCreatedEvent = (UserCreatedEvent) event;
        // 사용자 생성 이벤트 처리
    } else if (event instanceof UserUpdatedEvent) {
        UserUpdatedEvent userUpdatedEvent = (UserUpdatedEvent) event;
        // 사용자 업데이트 이벤트 처리
    }
}

@Service
public class UserService {
    
    private final ApplicationEventPublisher eventPublisher;
    
    @Autowired
    public UserService(ApplicationEventPublisher eventPublisher) {
        this.eventPublisher = eventPublisher;
    }
    
    public void registerUser(User user) {
        // 사용자 등록 로직
        userRepository.save(user);
        
        // 이벤트 발행
        eventPublisher.publishEvent(new UserRegisteredEvent(this, user));
    }
}

// POJO 이벤트 클래스
public class UserRegisteredEvent {
    
    private final User user;
    
    public UserRegisteredEvent(User user) {
        this.user = user;
    }
    
    public User getUser() {
        return user;
    }
}

// 이벤트 발행
eventPublisher.publishEvent(new UserRegisteredEvent(user));

// 주문 생성 이벤트
public class OrderCreatedEvent {
    private final Order order;
    
    public OrderCreatedEvent(Order order) {
        this.order = order;
    }
    
    public Order getOrder() {
        return order;
    }
}

// 주문 결제 완료 이벤트
public class OrderPaidEvent {
    private final Order order;
    private final Payment payment;
    
    public OrderPaidEvent(Order order, Payment payment) {
        this.order = order;
        this.payment = payment;
    }
    
    public Order getOrder() {
        return order;
    }
    
    public Payment getPayment() {
        return payment;
    }
}

@Service
public class OrderService {
    
    private final OrderRepository orderRepository;
    private final ApplicationEventPublisher eventPublisher;
    
    @Autowired
    public OrderService(OrderRepository orderRepository, ApplicationEventPublisher eventPublisher) {
        this.orderRepository = orderRepository;
        this.eventPublisher = eventPublisher;
    }
    
    @Transactional
    public Order createOrder(OrderRequest request) {
        // 주문 생성 로직
        Order order = new Order();
        order.setCustomerId(request.getCustomerId());
        order.setItems(request.getItems());
        order.setTotalAmount(calculateTotalAmount(request.getItems()));
        order.setStatus(OrderStatus.CREATED);
        
        Order savedOrder = orderRepository.save(order);
        
        // 주문 생성 이벤트 발행
        eventPublisher.publishEvent(new OrderCreatedEvent(savedOrder));
        
        return savedOrder;
    }
    
    @Transactional
    public Order processPayment(Long orderId, PaymentRequest paymentRequest) {
        Order order = orderRepository.findById(orderId)
                .orElseThrow(() -> new OrderNotFoundException(orderId));
        
        // 결제 처리 로직
        Payment payment = paymentService.processPayment(paymentRequest);
        
        order.setStatus(OrderStatus.PAID);
        Order updatedOrder = orderRepository.save(order);
        
        // 결제 완료 이벤트 발행
        eventPublisher.publishEvent(new OrderPaidEvent(updatedOrder, payment));
        
        return updatedOrder;
    }
    
    private BigDecimal calculateTotalAmount(List<orderitem> items) {
        // 주문 총액 계산 로직
        return items.stream()
                .map(item -> item.getPrice().multiply(BigDecimal.valueOf(item.getQuantity())))
                .reduce(BigDecimal.ZERO, BigDecimal::add);
    }
}</orderitem>

@Component
public class OrderEventListeners {
    
    private final EmailService emailService;
    private final InventoryService inventoryService;
    private final AnalyticsService analyticsService;
    
    @Autowired
    public OrderEventListeners(EmailService emailService, 
                              InventoryService inventoryService,
                              AnalyticsService analyticsService) {
        this.emailService = emailService;
        this.inventoryService = inventoryService;
        this.analyticsService = analyticsService;
    }
    
    @EventListener
    public void handleOrderCreatedEvent(OrderCreatedEvent event) {
        Order order = event.getOrder();
        
        // 주문 확인 이메일 발송
        emailService.sendOrderConfirmationEmail(order);
        
        // 재고 확인 및 예약
        inventoryService.reserveItems(order.getItems());
        
        // 주문 생성 분석 데이터 기록
        analyticsService.trackOrderCreated(order);
        
        System.out.println("주문 생성 이벤트 처리 완료: " + order.getId());
    }
    
    @EventListener
    public void handleOrderPaidEvent(OrderPaidEvent event) {
        Order order = event.getOrder();
        Payment payment = event.getPayment();
        
        // 결제 완료 이메일 발송
        emailService.sendPaymentConfirmationEmail(order, payment);
        
        // 배송 프로세스 시작
        shippingService.initiateShipping(order);
        
        // 결제 완료 분석 데이터 기록
        analyticsService.trackOrderPaid(order, payment);
        
        System.out.println("결제 완료 이벤트 처리 완료: " + order.getId());
    }
    
    // 특정 금액 이상의 주문에 대해서만 VIP 고객 서비스 알림
    @EventListener(condition = "#event.order.totalAmount.compareTo(new java.math.BigDecimal('100000')) > 0")
    public void handleLargeOrderPaid(OrderPaidEvent event) {
        Order order = event.getOrder();
        
        // VIP 고객 서비스팀에 알림
        customerServiceNotifier.notifyVipTeam(order);
        
        System.out.println("대규모 주문 알림 처리 완료: " + order.getId());
    }
}

@Configuration
@EnableAsync  // 비동기 처리 활성화
public class AsyncConfig {
    
    @Bean
    public TaskExecutor taskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(5);
        executor.setMaxPoolSize(10);
        executor.setQueueCapacity(25);
        executor.setThreadNamePrefix("Async-");
        executor.initialize();
        return executor;
    }
}

@Component
public class AsyncOrderEventListeners {
    
    private final EmailService emailService;
    private final AnalyticsService analyticsService;
    
    @Autowired
    public AsyncOrderEventListeners(EmailService emailService, AnalyticsService analyticsService) {
        this.emailService = emailService;
        this.analyticsService = analyticsService;
    }
    
    @Async
    @EventListener
    public void handleOrderCreatedEvent(OrderCreatedEvent event) {
        Order order = event.getOrder();
        
        // 시간이 오래 걸릴 수 있는 이메일 발송 작업
        emailService.sendOrderConfirmationEmail(order);
        
        System.out.println("비동기 주문 생성 이메일 발송 완료: " + order.getId() + 
                          " (Thread: " + Thread.currentThread().getName() + ")");
    }
    
    @Async
    @EventListener
    public void trackOrderAnalytics(OrderCreatedEvent event) {
        Order order = event.getOrder();
        
        // 시간이 오래 걸릴 수 있는 분석 데이터 처리
        analyticsService.trackDetailedOrderMetrics(order);
        
        System.out.println("비동기 주문 분석 처리 완료: " + order.getId() + 
                          " (Thread: " + Thread.currentThread().getName() + ")");
    }
}

@Async
@EventListener
public void handleOrderCreatedEvent(OrderCreatedEvent event) {
    try {
        // 비동기 처리 로직
        emailService.sendOrderConfirmationEmail(event.getOrder());
    } catch (Exception e) {
        // 예외 로깅
        log.error("Failed to process order created event", e);
        
        // 실패한 이벤트 저장 (나중에 재처리할 수 있도록)
        failedEventRepository.save(new FailedEvent(event, e.getMessage()));
    }
}

@Component
public class OrderTransactionalEventListener {
    
    private final EmailService emailService;
    
    @Autowired
    public OrderTransactionalEventListener(EmailService emailService) {
        this.emailService = emailService;
    }
    
    // 트랜잭션이 성공적으로 완료된 후에만 실행
    @TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)
    public void handleOrderCreatedEvent(OrderCreatedEvent event) {
        Order order = event.getOrder();
        emailService.sendOrderConfirmationEmail(order);
        System.out.println("트랜잭션 커밋 후 이메일 발송 완료: " + order.getId());
    }
    
    // 트랜잭션이 롤백된 후에 실행
    @TransactionalEventListener(phase = TransactionPhase.AFTER_ROLLBACK)
    public void handleOrderCreationFailed(OrderCreatedEvent event) {
        Order order = event.getOrder();
        System.out.println("주문 생성 트랜잭션 롤백됨: " + order.getId());
        // 롤백 관련 로깅 또는 모니터링 알림
    }
    
    // 트랜잭션 완료(커밋 또는 롤백) 후 실행
    @TransactionalEventListener(phase = TransactionPhase.AFTER_COMPLETION)
    public void handleOrderProcessingCompleted(OrderCreatedEvent event) {
        System.out.println("주문 처리 트랜잭션 완료됨 (커밋 또는 롤백)");
        // 리소스 정리 등
    }
    
    // 트랜잭션 커밋 전에 실행 (주의: 이 시점에서 예외 발생 시 트랜잭션이 롤백됨)
    @TransactionalEventListener(phase = TransactionPhase.BEFORE_COMMIT)
    public void validateOrderBeforeCommit(OrderCreatedEvent event) {
        Order order = event.getOrder();
        // 최종 유효성 검사 등
        System.out.println("트랜잭션 커밋 전 주문 최종 검증: " + order.getId());
    }
}

@TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT, fallbackExecution = true)
public void handleOrderCreatedEvent(OrderCreatedEvent event) {
    // 트랜잭션 유무에 관계없이 항상 실행됨
    emailService.sendOrderConfirmationEmail(event.getOrder());
}

@Configuration
public class EventObservationConfig {
    
    @Bean
    public ApplicationEventObservationConvention applicationEventObservationConvention() {
        return new CustomApplicationEventObservationConvention();
    }
}

public class CustomApplicationEventObservationConvention implements ApplicationEventObservationConvention {
    @Override
    public String getName() {
        return "events";
    }
    
    @Override
    public String getContextualName(ApplicationEventObservationContext context) {
        return "event-" + context.getApplicationEvent().getClass().getSimpleName();
    }
    
    @Override
    public KeyValues getLowCardinalityKeyValues(ApplicationEventObservationContext context) {
        return KeyValues.of("event.type", context.getApplicationEvent().getClass().getSimpleName());
    }
}

@Configuration
public class EventMulticasterConfig {
    
    @Bean
    public ApplicationEventMulticaster applicationEventMulticaster() {
        SimpleApplicationEventMulticaster eventMulticaster = new SimpleApplicationEventMulticaster();
        
        // 이벤트 처리를 위한 전용 스레드 풀 설정
        ThreadPoolTaskExecutor taskExecutor = new ThreadPoolTaskExecutor();
        taskExecutor.setCorePoolSize(10);
        taskExecutor.setMaxPoolSize(50);
        taskExecutor.setQueueCapacity(100);
        taskExecutor.setThreadNamePrefix("event-");
        taskExecutor.initialize();
        eventMulticaster.setTaskExecutor(taskExecutor);
        
        // 이벤트 처리 중 예외 발생 시 처리할 핸들러 설정
        eventMulticaster.setErrorHandler(throwable -> {
            log.error("이벤트 처리 중 오류 발생", throwable);
            // 추가 오류 처리 로직
        });
        
        return eventMulticaster;
    }
}

@Component
public class ReactiveEventListener {
    
    private final Sinks.Many<ordercreatedevent> orderCreatedSink = Sinks.many().multicast().onBackpressureBuffer();
    private final Flux<ordercreatedevent> orderCreatedFlux = orderCreatedSink.asFlux();
    
    @EventListener
    public void handleOrderCreatedEvent(OrderCreatedEvent event) {
        orderCreatedSink.tryEmitNext(event);
    }
    
    public Flux<ordercreatedevent> getOrderCreatedEvents() {
        return orderCreatedFlux;
    }
}</ordercreatedevent></ordercreatedevent></ordercreatedevent>

@EventListener
public void handleOrderCreatedEvent(OrderCreatedEvent event) {
    // AOT 컴파일 시 최적화되는 이벤트 처리 로직
    // 리플렉션을 최소화하고 직접 메소드 호출로 변환됨
}

@EventListener
public void handleOrderCreatedEvent(OrderCreatedEvent event) {
    // 구조화된 로깅
    log.atInfo()
       .addKeyValue("eventType", "OrderCreated")
       .addKeyValue("orderId", event.getOrder().getId())
       .addKeyValue("customerId", event.getOrder().getCustomerId())
       .addKeyValue("amount", event.getOrder().getTotalAmount())
       .log("Order created event processed");
    
    // 이벤트 처리 로직
}