feature: 좋아요 이벤트 처리 및 실패 이벤트 재시도 로직 추가

- `LikeCreatedEvent`를 통해 좋아요 이벤트 수집 및 비동기 처리 도입
- `FailedEvent` 및 관련 저장소/스케줄러 추가로 실패한 이벤트 관리 및 재시도 가능
- `LikeCountAggregateListener`로 좋아요 수 상태 비동기 업데이트 처리
- `DeadLetterQueueProcessor`를 통해 실패 이벤트 주기적 재 처리
- 트랜잭션 관리 및 이벤트 기반 구조로 서비스 안정성 강화

Author: yeonjiyeon

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

@@ -0,0 +1,47 @@
+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 java.util.List;
+import lombok.RequiredArgsConstructor;
+import org.springframework.context.ApplicationEventPublisher;
+import org.springframework.scheduling.annotation.Scheduled;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+
+@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,44 @@
+package com.loopers.application.event;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+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 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;
+
+  @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);
+    } catch (Exception e) {
+    }
+  }
+}

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,43 @@
 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);
-        });
+    Like newLike = likeService.save(userId, productId);
 
-      } catch (ObjectOptimisticLockingFailureException e) {
-        if (i == RETRY_COUNT - 1) {
-          throw e;
-        }
-        sleep(50);
-      }
-    }
-    throw new IllegalStateException("좋아요 처리 재시도 횟수를 초과했습니다.");
+    eventPublisher.publishEvent(new LikeCreatedEvent(productId, 1));
+
+    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);
 
-          return productService.decreaseLikeCount(productId);
+    eventPublisher.publishEvent(new LikeCreatedEvent(productId, -1));
 
-        });
+    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/product/LikeCountAggregateListener.java

@@ -0,0 +1,48 @@
+package com.loopers.application.product;
+
+import com.loopers.application.event.FailedEventStore;
+import com.loopers.application.like.LikeCreatedEvent;
+import com.loopers.domain.product.ProductService;
+import lombok.RequiredArgsConstructor;
+import org.springframework.orm.ObjectOptimisticLockingFailureException;
+import org.springframework.scheduling.annotation.Async;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Propagation;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.transaction.event.TransactionPhase;
+import org.springframework.transaction.event.TransactionalEventListener;
+
+@Component
+@RequiredArgsConstructor
+public class LikeCountAggregateListener {
+
+  private final ProductService productService;
+  private final FailedEventStore failedEventStore;
+
+
+  @Async
+  @TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)
+  public void handleLikeCreatedEvent(LikeCreatedEvent event) {
+
+    try {
+      performAggregation(event);
+
+    } catch (ObjectOptimisticLockingFailureException e) {
+
+      failedEventStore.scheduleRetry(event, "Optimistic Lock Conflict");
+
+    } catch (Exception e) {
+
+      failedEventStore.scheduleRetry(event, "Unexpected Error: " + e.getMessage());
+    }
+  }
+
+  @Transactional(propagation = Propagation.REQUIRES_NEW)
+  public void performAggregation(LikeCreatedEvent event) {
+    if (event.increment() > 0) {
+      productService.increaseLikeCount(event.productId());
+    } else {
+      productService.decreaseLikeCount(event.productId());
+    }
+  }
+}

apps/commerce-api/src/main/java/com/loopers/domain/event/DomainEvent.java

@@ -0,0 +1,5 @@
+package com.loopers.domain.event;
+
+public interface DomainEvent {
+
+}

apps/commerce-api/src/main/java/com/loopers/domain/event/FailedEvent.java

@@ -0,0 +1,42 @@
+package com.loopers.domain.event;
+
+import jakarta.persistence.Entity;
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.GenerationType;
+import jakarta.persistence.Id;
+import jakarta.persistence.Lob;
+import java.time.LocalDateTime;
+import lombok.AccessLevel;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+
+@Entity
+@Getter
+@NoArgsConstructor(access = AccessLevel.PROTECTED)
+public class FailedEvent {
+
+  @Id
+  @GeneratedValue(strategy = GenerationType.IDENTITY)
+  private Long id;
+
+  private String eventType;
+
+  @Lob
+  private String eventPayload;
+
+  private String failureReason;
+  private int retryCount;
+  private LocalDateTime createdAt;
+
+  public FailedEvent(String eventType, String eventPayload, String failureReason, int retryCount, LocalDateTime createdAt) {
+    this.eventType = eventType;
+    this.eventPayload = eventPayload;
+    this.failureReason = failureReason;
+    this.retryCount = retryCount;
+    this.createdAt = createdAt;
+  }
+
+  public void incrementRetryCount() {
+    this.retryCount++;
+  }
+}

apps/commerce-api/src/main/java/com/loopers/infrastructure/event/FailedEventRepository.java

@@ -0,0 +1,12 @@
+package com.loopers.infrastructure.event;
+
+import com.loopers.domain.event.FailedEvent;
+import java.util.List;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+@Repository
+public interface FailedEventRepository extends JpaRepository<FailedEvent, Long> {
+
+  List<FailedEvent> findByRetryCountLessThan(int maxRetries);
+}