Feature/event

apps/commerce-api/src/main/java/com/loopers/CommerceApiApplication.java

@@ -5,12 +5,14 @@
 import org.springframework.boot.autoconfigure.SpringBootApplication;
 import org.springframework.boot.context.properties.ConfigurationPropertiesScan;
 import org.springframework.cloud.openfeign.EnableFeignClients;
+import org.springframework.scheduling.annotation.EnableAsync;
 import org.springframework.scheduling.annotation.EnableScheduling;
 import java.util.TimeZone;
 
 @ConfigurationPropertiesScan
 @SpringBootApplication
 @EnableScheduling
+@EnableAsync
 @EnableFeignClients
 public class CommerceApiApplication {
 

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

@@ -0,0 +1,73 @@
+package com.loopers.application.coupon;
+
+import com.loopers.domain.coupon.CouponEvent;
+import com.loopers.domain.coupon.CouponEventPublisher;
+import com.loopers.domain.order.OrderEvent;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+
+/**
+ * 쿠폰 이벤트 핸들러.
+ * <p>
+ * 주문 생성 이벤트를 받아 쿠폰 사용 처리를 수행하는 애플리케이션 로직을 처리합니다.
+ * </p>
+ * <p>
+ * <b>DDD/EDA 관점:</b>
+ * <ul>
+ *   <li><b>책임 분리:</b> CouponService는 쿠폰 도메인 비즈니스 로직, CouponEventHandler는 이벤트 처리 로직</li>
+ *   <li><b>이벤트 핸들러:</b> 이벤트를 받아서 처리하는 역할을 명확히 나타냄</li>
+ *   <li><b>도메인 경계 준수:</b> 쿠폰 도메인은 쿠폰 적용 이벤트만 발행하고, 주문 도메인은 자신의 상태를 관리</li>
+ * </ul>
+ * </p>
+ *
+ * @author Loopers
+ * @version 1.0
+ */
+@Slf4j
+@Component
+@RequiredArgsConstructor
+public class CouponEventHandler {
+
+    private final CouponService couponService;
+    private final CouponEventPublisher couponEventPublisher;
+
+    /**
+     * 주문 생성 이벤트를 처리하여 쿠폰을 사용하고 쿠폰 적용 이벤트를 발행합니다.
+     * <p>
+     * 쿠폰 코드가 있는 경우에만 쿠폰 사용 처리를 수행합니다.
+     * 쿠폰 적용 후 CouponApplied 이벤트를 발행하여 주문 도메인이 자신의 상태를 업데이트하도록 합니다.
+     * </p>
+     *
+     * @param event 주문 생성 이벤트
+     */
+    @Transactional
+    public void handleOrderCreated(OrderEvent.OrderCreated event) {
+        // 쿠폰 코드가 없는 경우 처리하지 않음
+        if (event.couponCode() == null || event.couponCode().isBlank()) {
+            log.debug("쿠폰 코드가 없어 쿠폰 사용 처리를 건너뜁니다. (orderId: {})", event.orderId());
+            return;
+        }
+
+        // 쿠폰 사용 처리 (쿠폰 사용 마킹 및 할인 금액 계산)
+        Integer discountAmount = couponService.applyCoupon(
+                event.userId(),
+                event.couponCode(),
+                event.subtotal()
+        );
+
+        // ✅ 도메인 이벤트 발행: 쿠폰이 적용되었음 (과거 사실)
+        // 주문 도메인이 이 이벤트를 구독하여 자신의 상태를 업데이트함
+        couponEventPublisher.publish(CouponEvent.CouponApplied.of(
+                event.orderId(),
+                event.userId(),
+                event.couponCode(),
+                discountAmount
+        ));
+
+        log.info("쿠폰 사용 처리 완료. (orderId: {}, couponCode: {}, discountAmount: {})",
+                event.orderId(), event.couponCode(), discountAmount);
+    }
+}
+

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

@@ -76,6 +76,9 @@ public Integer applyCoupon(Long userId, String couponCode, Integer subtotal) {
             // 사용자 쿠폰 저장 (version 체크 자동 수행)
             // 다른 트랜잭션이 먼저 수정했다면 OptimisticLockException 발생
             userCouponRepository.save(userCoupon);
+            // ✅ flush()를 명시적으로 호출하여 Optimistic Lock 체크를 즉시 수행
+            // flush() 없이는 트랜잭션 커밋 시점에 체크되므로, 여러 트랜잭션이 동시에 성공할 수 있음
+            userCouponRepository.flush();
         } catch (ObjectOptimisticLockingFailureException e) {
             // 낙관적 락 충돌: 다른 트랜잭션이 먼저 쿠폰을 사용함
             throw new CoreException(ErrorType.CONFLICT,

apps/commerce-api/src/main/java/com/loopers/application/heart/HeartFacade.java

@@ -1,7 +1,6 @@
 package com.loopers.application.heart;
 
 import com.loopers.application.like.LikeService;
-import com.loopers.application.product.ProductCacheService;
 import com.loopers.application.product.ProductService;
 import com.loopers.application.user.UserService;
 import com.loopers.domain.like.Like;
@@ -23,6 +22,14 @@
  * <p>
  * 좋아요 추가, 삭제, 목록 조회 유즈케이스를 처리하는 애플리케이션 서비스입니다.
  * </p>
+ * <p>
+ * <b>EDA 원칙 준수:</b>
+ * <ul>
+ *   <li><b>이벤트 기반:</b> Like 도메인 이벤트만 발행하고, 다른 애그리거트를 직접 수정하지 않음</li>
+ *   <li><b>느슨한 결합:</b> Product, User 애그리거트와의 직접적인 의존성 최소화</li>
+ *   <li><b>책임 분리:</b> 좋아요 도메인만 관리하고, 상품 좋아요 수 집계는 이벤트 핸들러에서 처리</li>
+ * </ul>
+ * </p>
  *
  * @author Loopers
  * @version 1.0
@@ -31,9 +38,8 @@
 @Component
 public class HeartFacade {
     private final LikeService likeService;
-    private final UserService userService;
-    private final ProductService productService;
-    private final ProductCacheService productCacheService;
+    private final UserService userService; // String userId를 Long id로 변환하는 데만 사용
+    private final ProductService productService; // getLikedProducts 조회용으로만 사용
 
     /**
      * 상품에 좋아요를 추가합니다.
@@ -57,14 +63,23 @@ public class HeartFacade {
      *   <li><b>비즈니스 데이터 보호:</b> 중복 좋아요로 인한 비즈니스 데이터 오염 방지</li>
      * </ul>
      * </p>
+     * <p>
+     * <b>EDA 원칙:</b>
+     * <ul>
+     *   <li><b>이벤트 기반:</b> LikeService.save()가 LikeEvent.LikeAdded 이벤트를 발행</li>
+     *   <li><b>느슨한 결합:</b> Product 애그리거트를 직접 조회/수정하지 않음. 이벤트 핸들러가 상품 좋아요 수를 업데이트</li>
+     *   <li><b>책임 분리:</b> 좋아요 도메인만 관리하고, 상품 좋아요 수 집계는 ProductEventHandler에서 처리</li>
+     * </ul>
+     * </p>
      *
      * @param userId 사용자 ID (String)
      * @param productId 상품 ID
-     * @throws CoreException 사용자 또는 상품을 찾을 수 없는 경우
+     * @throws CoreException 사용자를 찾을 수 없는 경우
      */
     public void addLike(String userId, Long productId) {
+        // ✅ EDA 원칙: UserService는 String userId를 Long id로 변환하는 데만 사용
+        // Product 존재 여부 검증은 제거 (이벤트 핸들러에서 처리하거나, 외래키 제약조건으로 보장)
         User user = loadUser(userId);
-        loadProduct(productId);
 
         // 먼저 일반 조회로 중복 체크 (대부분의 경우 빠르게 처리)
         // ⚠️ 주의: 애플리케이션 레벨 체크만으로는 race condition을 완전히 방지할 수 없음
@@ -76,18 +91,16 @@ public void addLike(String userId, Long productId) {
 
         // 저장 시도 (동시성 상황에서는 UNIQUE 제약조건 위반 예외 발생 가능)
         // ✅ UNIQUE 제약조건이 최종 보호: DB 레벨에서 중복 삽입을 물리적으로 방지
-        // @Transactional이 없어도 save() 호출 시 자동 트랜잭션으로 예외를 catch할 수 있음
+        // ✅ LikeService.save()가 LikeEvent.LikeAdded 이벤트를 발행
+        // ✅ ProductEventHandler가 이벤트를 구독하여 상품 좋아요 수 및 캐시 업데이트
         Like like = Like.of(user.getId(), productId);
         try {
             likeService.save(like);
-            // 좋아요 추가 성공 시 로컬 캐시의 델타 증가
-            productCacheService.incrementLikeCountDelta(productId);
         } catch (org.springframework.dao.DataIntegrityViolationException e) {
             // UNIQUE 제약조건 위반 = 이미 저장됨 (멱등성 보장)
             // 동시에 여러 요청이 들어와서 모두 "없음"으로 판단하고 저장을 시도할 때,
             // 첫 번째만 성공하고 나머지는 UNIQUE 제약조건 위반 예외 발생
             // 이미 좋아요가 존재하는 경우이므로 정상 처리로 간주
-            // 로컬 캐시는 업데이트하지 않음 (이미 좋아요가 존재하므로)
         }
     }
 
@@ -96,28 +109,36 @@ public void addLike(String userId, Long productId) {
      * <p>
      * 멱등성을 보장합니다. 좋아요가 존재하지 않는 경우 아무 작업도 수행하지 않습니다.
      * </p>
+     * <p>
+     * <b>EDA 원칙:</b>
+     * <ul>
+     *   <li><b>이벤트 기반:</b> LikeService.delete()가 LikeEvent.LikeRemoved 이벤트를 발행</li>
+     *   <li><b>느슨한 결합:</b> Product 애그리거트를 직접 조회/수정하지 않음. 이벤트 핸들러가 상품 좋아요 수를 업데이트</li>
+     *   <li><b>책임 분리:</b> 좋아요 도메인만 관리하고, 상품 좋아요 수 집계는 ProductEventHandler에서 처리</li>
+     * </ul>
+     * </p>
      *
      * @param userId 사용자 ID (String)
      * @param productId 상품 ID
-     * @throws CoreException 사용자 또는 상품을 찾을 수 없는 경우
+     * @throws CoreException 사용자를 찾을 수 없는 경우
      */
     public void removeLike(String userId, Long productId) {
+        // ✅ EDA 원칙: UserService는 String userId를 Long id로 변환하는 데만 사용
+        // Product 존재 여부 검증은 제거 (이벤트 핸들러에서 처리하거나, 외래키 제약조건으로 보장)
         User user = loadUser(userId);
-        loadProduct(productId);
 
         Optional<Like> like = likeService.getLike(user.getId(), productId);
         if (like.isEmpty()) {
             return;
         }
 
         try {
+            // ✅ LikeService.delete()가 LikeEvent.LikeRemoved 이벤트를 발행
+            // ✅ ProductEventHandler가 이벤트를 구독하여 상품 좋아요 수 및 캐시 업데이트
             likeService.delete(like.get());
-            // 좋아요 취소 성공 시 로컬 캐시의 델타 감소
-            productCacheService.decrementLikeCountDelta(productId);
         } catch (Exception e) {
             // 동시성 상황에서 이미 삭제된 경우 등 예외 발생 가능
             // 멱등성 보장: 이미 삭제된 경우 정상 처리로 간주
-            // 로컬 캐시는 업데이트하지 않음 (이미 삭제되었으므로)
         }
     }
 
@@ -129,11 +150,18 @@ public void removeLike(String userId, Long productId) {
      * <p>
      * <b>좋아요 수 조회 전략:</b>
      * <ul>
-     *   <li><b>비동기 집계:</b> Product.likeCount 필드 사용 (스케줄러로 주기적 동기화)</li>
-     *   <li><b>Eventually Consistent:</b> 약간의 지연 허용 (최대 5초)</li>
+     *   <li><b>이벤트 기반 집계:</b> Product.likeCount 필드 사용 (LikeEvent로 실시간 업데이트)</li>
+     *   <li><b>Strong Consistency:</b> 이벤트 기반으로 실시간 반영</li>
      *   <li><b>성능 최적화:</b> COUNT(*) 쿼리 없이 컬럼만 읽으면 됨</li>
      * </ul>
      * </p>
+     * <p>
+     * <b>EDA 원칙:</b>
+     * <ul>
+     *   <li><b>조회 특성:</b> 조회 쿼리는 이벤트로 처리하기 어려우므로 ProductService 의존 허용</li>
+     *   <li><b>최소 의존:</b> 조회용으로만 사용하며, 수정 작업은 수행하지 않음</li>
+     * </ul>
+     * </p>
      *
      * @param userId 사용자 ID (String)
      * @return 좋아요한 상품 목록
@@ -156,6 +184,7 @@ public List<LikedProduct> getLikedProducts(String userId) {
             .toList();
 
         // ✅ 배치 조회로 N+1 쿼리 문제 해결
+        // ⚠️ 조회 특성상 ProductService 의존은 허용 (이벤트로 처리하기 어려움)
         Map<Long, Product> productMap = productService.getProducts(productIds).stream()
             .collect(Collectors.toMap(Product::getId, product -> product));
 
@@ -165,7 +194,7 @@ public List<LikedProduct> getLikedProducts(String userId) {
         }
 
         // 좋아요 목록을 상품 정보와 좋아요 수와 함께 변환
-        // ✅ Product.likeCount 필드 사용 (비동기 집계된 값)
+        // ✅ Product.likeCount 필드 사용 (이벤트 기반 실시간 집계된 값)
         return likes.stream()
             .map(like -> {
                 Product product = productMap.get(like.getProductId());
@@ -179,14 +208,20 @@ public List<LikedProduct> getLikedProducts(String userId) {
             .toList();
     }
 
+    /**
+     * String userId를 Long id로 변환합니다.
+     * <p>
+     * EDA 원칙에 따라 최소한의 UserService 의존만 사용합니다.
+     * </p>
+     *
+     * @param userId 사용자 ID (String)
+     * @return 사용자 엔티티
+     * @throws CoreException 사용자를 찾을 수 없는 경우
+     */
     private User loadUser(String userId) {
         return userService.getUser(userId);
     }
 
-    private Product loadProduct(Long productId) {
-        return productService.getProduct(productId);
-    }
-
     /**
      * 좋아요한 상품 정보.
      *
@@ -225,7 +260,7 @@ public static LikedProduct from(Product product) {
                 product.getPrice(),
                 product.getStock(),
                 product.getBrandId(),
-                product.getLikeCount() // ✅ Product.likeCount 필드 사용 (비동기 집계된 값)
+                product.getLikeCount() // ✅ Product.likeCount 필드 사용 (이벤트 기반 실시간 집계된 값)
             );
         }
     }

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

@@ -1,6 +1,8 @@
 package com.loopers.application.like;
 
 import com.loopers.domain.like.Like;
+import com.loopers.domain.like.LikeEvent;
+import com.loopers.domain.like.LikeEventPublisher;
 import com.loopers.domain.like.LikeRepository;
 import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Component;
@@ -23,6 +25,7 @@
 @Component
 public class LikeService {
     private final LikeRepository likeRepository;
+    private final LikeEventPublisher likeEventPublisher;
 
     /**
      * 사용자 ID와 상품 ID로 좋아요를 조회합니다.
@@ -38,22 +41,36 @@ public Optional<Like> getLike(Long userId, Long productId) {
 
     /**
      * 좋아요를 저장합니다.
+     * <p>
+     * 저장 성공 시 좋아요 추가 이벤트를 발행합니다.
+     * </p>
      *
      * @param like 저장할 좋아요
      * @return 저장된 좋아요
      */
     @Transactional
     public Like save(Like like) {
-        return likeRepository.save(like);
+        Like savedLike = likeRepository.save(like);
+
+        // ✅ 도메인 이벤트 발행: 좋아요가 추가되었음 (과거 사실)
+        likeEventPublisher.publish(LikeEvent.LikeAdded.from(savedLike));
+
+        return savedLike;
     }
 
     /**
      * 좋아요를 삭제합니다.
+     * <p>
+     * 삭제 전에 좋아요 취소 이벤트를 발행합니다.
+     * </p>
      *
      * @param like 삭제할 좋아요
      */
     @Transactional
     public void delete(Like like) {
+        // ✅ 도메인 이벤트 발행: 좋아요가 취소되었음 (과거 사실)
+        likeEventPublisher.publish(LikeEvent.LikeRemoved.from(like));
+
         likeRepository.delete(like);
     }