Merge pull request #181 from yeonjiyeon/feature/week7

[volume-7] Decoupling with Event

Author: yeonjiyeon

apps/commerce-api/src/main/java/com/loopers/application/coupon/CouponUsageEventListener.java

@@ -0,0 +1,35 @@
+package com.loopers.application.coupon;
+
+import com.loopers.application.event.FailedEventStore;
+import com.loopers.application.payment.PaymentEvent.PaymentCompletedEvent;
+import com.loopers.domain.coupon.CouponService;
+import lombok.RequiredArgsConstructor;
+import org.springframework.orm.ObjectOptimisticLockingFailureException;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.transaction.event.TransactionPhase;
+import org.springframework.transaction.event.TransactionalEventListener;
+
+@Component
+@RequiredArgsConstructor
+public class CouponUsageEventListener {
+  private final CouponService couponService;
+  private final FailedEventStore failedEventStore;
+
+  @TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)
+  @Transactional
+  public void handlePaymentCompletedEvent(PaymentCompletedEvent event) {
+
+    if (event.couponId() == null) return;
+
+    try {
+      couponService.confirmCouponUsage(event.couponId());
+
+    } catch (ObjectOptimisticLockingFailureException e) {
+      failedEventStore.scheduleRetry(event, "Coupon Lock Conflict on Confirmation");
+
+    } catch (Exception e) {
+      failedEventStore.scheduleRetry(event, "Coupon confirmation error: " + e.getMessage());
+    }
+  }
+}

apps/commerce-api/src/main/java/com/loopers/application/dataplatform/DataPlatformEventListener.java

@@ -0,0 +1,22 @@
+package com.loopers.application.dataplatform;
+
+import com.loopers.application.payment.PaymentEvent.PaymentCompletedEvent;
+import com.loopers.domain.dataplatform.DataPlatformGateway;
+import lombok.RequiredArgsConstructor;
+import org.springframework.scheduling.annotation.Async;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.event.TransactionPhase;
+import org.springframework.transaction.event.TransactionalEventListener;
+
+@Component
+@RequiredArgsConstructor
+public class DataPlatformEventListener {
+
+  private final DataPlatformGateway dataPlatformGateway;
+
+  @Async
+  @TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)
+  public void handleOrderCreatedEvent(PaymentCompletedEvent event) {
+    dataPlatformGateway.sendPaymentData(event.orderId(), event.paymentId());
+  }
+}

apps/commerce-api/src/main/java/com/loopers/application/event/DeadLetterQueueProcessor.java

@@ -0,0 +1,49 @@
+package com.loopers.application.event;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.loopers.domain.event.DomainEvent;
+import com.loopers.domain.event.FailedEvent;
+import com.loopers.infrastructure.event.FailedEventRepository;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.context.ApplicationEventPublisher;
+import org.springframework.scheduling.annotation.Scheduled;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.List;
+
+@Component
+@RequiredArgsConstructor
+public class DeadLetterQueueProcessor {
+
+  private final FailedEventRepository failedEventRepository;
+  private final ApplicationEventPublisher eventPublisher;
+  private final ObjectMapper objectMapper;
+
+  private static final int MAX_RETRY_COUNT = 5;
+
+  @Scheduled(fixedRate = 300000)
+  @Transactional 
+  public void retryFailedEvents() {
+
+    List<FailedEvent> eventsToRetry = failedEventRepository.findByRetryCountLessThan(MAX_RETRY_COUNT);
+
+    if (eventsToRetry.isEmpty()) return;
+
+    for (FailedEvent failedEvent : eventsToRetry) {
+      try {
+        Class<?> eventClass = Class.forName(failedEvent.getEventType());
+        DomainEvent originalEvent = (DomainEvent) objectMapper.readValue(
+            failedEvent.getEventPayload(), eventClass);
+
+        eventPublisher.publishEvent(originalEvent);
+        failedEventRepository.delete(failedEvent);
+
+      } catch (Exception e) {
+        failedEvent.incrementRetryCount(); 
+        failedEventRepository.save(failedEvent);
+      }
+    }
+  }
+}

apps/commerce-api/src/main/java/com/loopers/application/event/FailedEventScheduler.java

@@ -0,0 +1,8 @@
+package com.loopers.application.event;
+
+import com.loopers.domain.event.DomainEvent;
+
+public interface FailedEventScheduler {
+
+  <T extends DomainEvent> void scheduleRetry(T event, String reason);
+}

apps/commerce-api/src/main/java/com/loopers/application/event/FailedEventStore.java

@@ -0,0 +1,50 @@
+package com.loopers.application.event;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.loopers.application.monitoring.port.MonitoringService;
+import com.loopers.domain.event.DomainEvent;
+import com.loopers.domain.event.FailedEvent;
+import com.loopers.infrastructure.event.FailedEventRepository;
+import java.time.LocalDateTime;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+
+@Component
+@RequiredArgsConstructor
+public class FailedEventStore implements FailedEventScheduler {
+
+  private final FailedEventRepository failedEventRepository;
+  private final ObjectMapper objectMapper;
+  private final MonitoringService monitoringService;
+
+  @Transactional
+  @Override
+  public <T extends DomainEvent> void scheduleRetry(T event, String reason) {
+    String payload;
+
+    try {
+      payload = objectMapper.writeValueAsString(event);
+    } catch (JsonProcessingException e) {
+      return;
+    }
+
+    FailedEvent failedEvent = new FailedEvent(
+        event.getClass().getName(),
+        payload,
+        reason,
+        0,
+        LocalDateTime.now()
+    );
+
+    try {
+      failedEventRepository.save(failedEvent);
+      monitoringService.incrementMetric("dlq.event_saved_total", "type:" + failedEvent.getEventType());
+
+    } catch (Exception e) {
+      monitoringService.sendCriticalAlert(
+          "CRITICAL: DLQ 저장소 장애. 이벤트 유실 위험 발생! 사유: " + e.getMessage(), e);
+    }
+  }
+}

apps/commerce-api/src/main/java/com/loopers/application/like/LikeActionTrackEvent.java

@@ -0,0 +1,30 @@
+package com.loopers.application.like;
+
+import com.loopers.domain.event.UserActionTrackEvent;
+import java.time.ZonedDateTime;
+import java.util.Map;
+
+public record LikeActionTrackEvent(
+    Long userId,
+    Long productId,
+    String action,
+
+    ZonedDateTime eventTime,
+    Map<String, Object> properties
+
+) implements UserActionTrackEvent {
+
+  public LikeActionTrackEvent(Long userId, Long productId, String action) {
+    this(userId, productId, action, ZonedDateTime.now(), Map.of());
+  }
+
+  @Override
+  public String eventType() {
+    return "LIKE_ACTION";
+  }
+
+  @Override
+  public Map<String, Object> getProperties() {
+    return properties;
+  }
+}

apps/commerce-api/src/main/java/com/loopers/application/like/LikeCreatedEvent.java

@@ -0,0 +1,10 @@
+package com.loopers.application.like;
+
+import com.loopers.domain.event.DomainEvent;
+
+public record LikeCreatedEvent(
+    long productId,
+    int increment
+) implements DomainEvent {
+
+}

apps/commerce-api/src/main/java/com/loopers/application/like/LikeFacade.java

@@ -6,75 +6,55 @@
 import com.loopers.domain.product.ProductService;
 import java.util.Optional;
 import lombok.RequiredArgsConstructor;
-import org.springframework.orm.ObjectOptimisticLockingFailureException;
+import org.springframework.context.ApplicationEventPublisher;
 import org.springframework.stereotype.Component;
-import org.springframework.transaction.support.TransactionTemplate;
+import org.springframework.transaction.annotation.Transactional;
 
 @RequiredArgsConstructor
 @Component
 public class LikeFacade {
 
   private final ProductService productService;
   private final LikeService likeService;
-  private final TransactionTemplate transactionTemplate;
-
-  private static final int RETRY_COUNT = 30;
+  private final ApplicationEventPublisher eventPublisher;
 
+  @Transactional
   public LikeInfo like(long userId, long productId) {
     Optional<Like> existingLike = likeService.findLike(userId, productId);
+    Product product = productService.getProduct(productId);
 
     if (existingLike.isPresent()) {
-      Product product = productService.getProduct(productId);
       return LikeInfo.from(existingLike.get(), product.getLikeCount());
     }
 
-    for (int i = 0; i < RETRY_COUNT; i++) {
-      try {
-        return transactionTemplate.execute(status -> {
-          Like newLike = likeService.save(userId, productId);
-          int updatedLikeCount = productService.increaseLikeCount(productId);
-          return LikeInfo.from(newLike, updatedLikeCount);
-        });
-
-      } catch (ObjectOptimisticLockingFailureException e) {
-        if (i == RETRY_COUNT - 1) {
-          throw e;
-        }
-        sleep(50);
-      }
-    }
-    throw new IllegalStateException("좋아요 처리 재시도 횟수를 초과했습니다.");
+    Like newLike = likeService.save(userId, productId);
+
+    eventPublisher.publishEvent(new LikeCreatedEvent(productId, 1));
+
+    eventPublisher.publishEvent(new LikeActionTrackEvent(
+        userId,
+        productId,
+        "LIKE"
+    ));
+
+    return LikeInfo.from(newLike, product.getLikeCount());
   }
 
+  @Transactional
   public int unLike(long userId, long productId) {
-    for (int i = 0; i < RETRY_COUNT; i++) {
-      try {
 
-        return transactionTemplate.execute(status -> {
+    likeService.unLike(userId, productId);
 
-          likeService.unLike(userId, productId);
+    eventPublisher.publishEvent(new LikeCreatedEvent(productId, -1));
 
-          return productService.decreaseLikeCount(productId);
+    eventPublisher.publishEvent(new LikeActionTrackEvent(
+        userId,
+        productId,
+        "UNLIKE"
+    ));
 
-        });
+    return productService.getProduct(productId).getLikeCount();
 
-      } catch (ObjectOptimisticLockingFailureException e) {
-
-        if (i == RETRY_COUNT - 1) {
-          throw e;
-        }
-        sleep(50);
-      }
-    }
-    throw new IllegalStateException("싫어요 처리 재시도 횟수를 초과했습니다.");
   }
 
-  private void sleep(long millis) {
-    try {
-      Thread.sleep(millis);
-    } catch (InterruptedException e) {
-      Thread.currentThread().interrupt();
-      throw new RuntimeException(e);
-    }
-  }
 }

apps/commerce-api/src/main/java/com/loopers/application/monitoring/port/DummyMonitoringAdapter.java

@@ -0,0 +1,18 @@
+package com.loopers.application.monitoring.port;
+
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Component;
+
+@Slf4j
+@Component
+public class DummyMonitoringAdapter implements MonitoringService {
+  @Override
+  public void incrementMetric(String name, String tag) {
+    log.info("[METRIC_DUMMY] Increment | Name: {} | Tag: {}", name, tag);
+  }
+
+  @Override
+  public void sendCriticalAlert(String message, Throwable t) {
+    log.error("[ALERT_DUMMY] CRITICAL ALERT: {}", message, t);
+  }
+}

apps/commerce-api/src/main/java/com/loopers/application/monitoring/port/MonitoringService.java

@@ -0,0 +1,8 @@
+package com.loopers.application.monitoring.port;
+
+public interface MonitoringService {
+
+  void incrementMetric(String name, String tag);
+
+  void sendCriticalAlert(String message, Throwable t);
+}