[Volume 7] 이벤트 기반 아키텍처 및 Kafka 파이프라인 구축

apps/commerce-api/build.gradle.kts

@@ -2,6 +2,7 @@ dependencies {
     // add-ons
     implementation(project(":modules:jpa"))
     implementation(project(":modules:redis"))
+    implementation(project(":modules:kafka"))
     implementation(project(":supports:jackson"))
     implementation(project(":supports:logging"))
     implementation(project(":supports:monitoring"))
@@ -25,6 +26,9 @@ dependencies {
     // security
     implementation("org.springframework.security:spring-security-crypto")
 
+    // mail
+    implementation("org.springframework.boot:spring-boot-starter-mail")
+
     // querydsl
     annotationProcessor("com.querydsl:querydsl-apt::jakarta")
     annotationProcessor("jakarta.persistence:jakarta.persistence-api")

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

@@ -6,8 +6,10 @@
 import org.springframework.boot.context.properties.ConfigurationPropertiesScan;
 import org.springframework.cloud.openfeign.EnableFeignClients;
 import org.springframework.retry.annotation.EnableRetry;
+import org.springframework.scheduling.annotation.EnableScheduling;
 import java.util.TimeZone;
 
+@EnableScheduling
 @EnableRetry
 @EnableFeignClients
 @ConfigurationPropertiesScan

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

@@ -2,14 +2,20 @@
 
 import com.loopers.application.coupon.dto.CouponCriteria;
 import com.loopers.application.coupon.dto.CouponResult;
+import com.loopers.application.coupon.event.CouponIssuedMessage;
+import com.loopers.confg.kafka.KafkaTopics;
+import com.loopers.domain.coupon.CouponErrorCode;
+import com.loopers.domain.coupon.CouponIssueLimiter;
+import com.loopers.domain.coupon.CouponIssueResult;
+import com.loopers.domain.coupon.CouponModel;
 import com.loopers.domain.coupon.CouponService;
+import com.loopers.infrastructure.outbox.OutboxEventPublisher;
+import com.loopers.support.error.CoreException;
 import java.util.List;
+import java.util.Map;
 import lombok.RequiredArgsConstructor;
 import org.springframework.data.domain.Page;
 import org.springframework.data.domain.Pageable;
-import org.springframework.orm.ObjectOptimisticLockingFailureException;
-import org.springframework.retry.annotation.Backoff;
-import org.springframework.retry.annotation.Retryable;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
@@ -18,23 +24,32 @@
 public class CouponFacade {
 
     private final CouponService couponService;
+    private final CouponIssueLimiter couponIssueLimiter;
+    private final OutboxEventPublisher outboxEventPublisher;
 
     @Transactional
     public CouponResult.Detail registerCoupon(CouponCriteria.Create criteria) {
-        return CouponResult.Detail.from(
-                couponService.register(criteria.toCommand()));
+        CouponModel coupon = couponService.register(criteria.toCommand());
+        couponIssueLimiter.registerTotalQuantity(coupon.getId(), coupon.getTotalQuantity());
+        return CouponResult.Detail.from(coupon, 0);
     }
 
     @Transactional(readOnly = true)
     public CouponResult.Detail getCoupon(Long couponId) {
         return CouponResult.Detail.from(
-                couponService.getById(couponId));
+                couponService.getById(couponId),
+                couponService.countIssuedCoupons(couponId));
     }
 
     @Transactional(readOnly = true)
     public Page<CouponResult.Detail> getCoupons(Pageable pageable) {
-        return couponService.getAll(pageable)
-                .map(CouponResult.Detail::from);
+        Page<CouponModel> coupons = couponService.getAll(pageable);
+        List<Long> couponIds = coupons.getContent().stream()
+                .map(CouponModel::getId)
+                .toList();
+        Map<Long, Long> issuedCountMap = couponService.countIssuedCoupons(couponIds);
+        return coupons.map(coupon -> CouponResult.Detail.from(
+                coupon, issuedCountMap.getOrDefault(coupon.getId(), 0L)));
     }
 
     @Transactional
@@ -53,14 +68,30 @@ public Page<CouponResult.IssuedDetail> getIssuedCoupons(Long couponId, Pageable
                 .map(CouponResult.IssuedDetail::from);
     }
 
-    @Retryable(
-            retryFor = ObjectOptimisticLockingFailureException.class,
-            maxAttempts = 50,
-            backoff = @Backoff(delay = 50, random = true))
     @Transactional
     public CouponResult.IssuedDetail issueCoupon(Long couponId, Long userId) {
-        return CouponResult.IssuedDetail.from(
-                couponService.issue(couponId, userId));
+        CouponIssueResult result = couponIssueLimiter.tryIssue(couponId, userId);
+        if (result == CouponIssueResult.NOT_FOUND) {
+            throw new CoreException(CouponErrorCode.NOT_FOUND);
+        }
+        if (result == CouponIssueResult.ALREADY_ISSUED) {
+            throw new CoreException(CouponErrorCode.ALREADY_ISSUED);
+        }
+        if (result == CouponIssueResult.QUANTITY_EXHAUSTED) {
+            throw new CoreException(CouponErrorCode.QUANTITY_EXHAUSTED);
+        }
+
+        try {
+            outboxEventPublisher.publish(
+                    "COUPON_ISSUED",
+                    KafkaTopics.COUPON_ISSUED,
+                    String.valueOf(couponId),
+                    new CouponIssuedMessage(couponId, userId, System.currentTimeMillis()));
+            return CouponResult.IssuedDetail.pending(couponId, userId);
+        } catch (Exception e) {
+            couponIssueLimiter.rollback(couponId, userId);
+            throw e;
+        }
     }
 
     @Transactional(readOnly = true)

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

@@ -14,20 +14,20 @@ public record Detail(
         long discountValue,
         Long minOrderAmount,
         int totalQuantity,
-        int issuedQuantity,
+        long issuedQuantity,
         ZonedDateTime expiredAt,
         ZonedDateTime createdAt,
         ZonedDateTime updatedAt
     ) {
-        public static Detail from(CouponModel model) {
+        public static Detail from(CouponModel model, long issuedQuantity) {
             return new Detail(
                     model.getId(),
                     model.getName(),
                     model.getDiscountType().name(),
                     model.getDiscountValue(),
                     model.getMinOrderAmount(),
                     model.getTotalQuantity(),
-                    model.getIssuedQuantity(),
+                    issuedQuantity,
                     model.getExpiredAt(),
                     model.getCreatedAt(),
                     model.getUpdatedAt());
@@ -49,6 +49,10 @@ public static IssuedDetail from(OwnedCouponModel model) {
                     model.getUsedAt(),
                     model.getCreatedAt());
         }
+
+        public static IssuedDetail pending(Long couponId, Long userId) {
+            return new IssuedDetail(null, userId, "PENDING", null, null);
+        }
     }
 
     public record OwnedDetail(

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

@@ -0,0 +1,7 @@
+package com.loopers.application.coupon.event;
+
+public record CouponIssuedMessage(
+        Long couponId,
+        Long userId,
+        long issuedAt
+) {}

apps/commerce-api/src/main/java/com/loopers/application/notification/OrderNotificationHandler.java

@@ -0,0 +1,35 @@
+package com.loopers.application.notification;
+
+import com.loopers.domain.order.event.OrderCompletedEvent;
+import com.loopers.domain.notification.NotificationSender;
+import com.loopers.domain.user.UserService;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.scheduling.annotation.Async;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.event.TransactionPhase;
+import org.springframework.transaction.event.TransactionalEventListener;
+
+@Slf4j
+@Component
+@RequiredArgsConstructor
+public class OrderNotificationHandler {
+
+    private final UserService userService;
+    private final NotificationSender notificationSender;
+
+    @Async
+    @TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)
+    public void handle(OrderCompletedEvent event) {
+        try {
+            String email = userService.getById(event.userId()).getEmail();
+            notificationSender.send(
+                    email,
+                    "주문이 확정되었습니다",
+                    String.format("주문번호 %d의 결제가 완료되어 주문이 확정되었습니다.", event.orderId()));
+        } catch (Exception e) {
+            log.warn("[Email] 발송 실패 — orderId={}, userId={}",
+                    event.orderId(), event.userId(), e);
+        }
+    }
+}

apps/commerce-api/src/main/java/com/loopers/application/order/OrderFacade.java

@@ -2,6 +2,7 @@
 
 import com.loopers.application.order.dto.OrderCriteria;
 import com.loopers.application.order.dto.OrderResult;
+import com.loopers.application.order.event.OrderPaymentEvent;
 import com.loopers.domain.brand.BrandService;
 import com.loopers.domain.coupon.CouponService;
 import com.loopers.domain.order.OrderModel;
@@ -14,11 +15,9 @@
 import java.util.List;
 import java.util.Map;
 import lombok.RequiredArgsConstructor;
+import org.springframework.context.ApplicationEventPublisher;
 import org.springframework.data.domain.Page;
 import org.springframework.data.domain.Pageable;
-import org.springframework.orm.ObjectOptimisticLockingFailureException;
-import org.springframework.retry.annotation.Backoff;
-import org.springframework.retry.annotation.Retryable;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
@@ -31,22 +30,41 @@ public class OrderFacade {
     private final OrderService orderService;
     private final CouponService couponService;
     private final UserService userService;
+    private final ApplicationEventPublisher eventPublisher;
 
-    @Retryable(
-            retryFor = ObjectOptimisticLockingFailureException.class,
-            maxAttempts = 10,
-            backoff = @Backoff(delay = 50, random = true))
     @Transactional
     public OrderResult.OrderSummary createOrder(Long userId, OrderCriteria.Create criteria) {
+        OrderModel order = processOrder(userId, criteria);
+        return OrderResult.OrderSummary.from(order);
+    }
+
+    @Transactional
+    public OrderResult.OrderPaymentSummary createOrderWithPayment(
+            Long userId, OrderCriteria.Create criteria) {
+
+        OrderModel order = processOrder(userId, criteria);
+
+        // PG 결제는 TX 커밋 후 이벤트로 처리
+        eventPublisher.publishEvent(new OrderPaymentEvent(
+                order.getId(), userId, order.getTotalPrice(),
+                criteria.cardType(), criteria.cardNo()));
+
+        return OrderResult.OrderPaymentSummary.pending(order);
+    }
+
+    private OrderModel processOrder(Long userId, OrderCriteria.Create criteria) {
+        // 1. 재고 차감
         List<ProductInfo.StockDeduction> deductionInfos =
                 productService.validateAndDeductStock(criteria.toStockDeductions());
 
         Map<Long, String> brandNameMap = brandService.getNameMapByIds(
                 ProductInfo.StockDeduction.extractDistinctBrandIds(deductionInfos));
 
+        // 2. 주문 생성
         OrderModel order = orderService.createOrder(
                 userId, OrderCommand.CreateItem.from(deductionInfos, brandNameMap));
 
+        // 3. 쿠폰 사용
         if (criteria.ownedCouponId() != null) {
             orderService.applyDiscount(
                     order,
@@ -55,9 +73,10 @@ public OrderResult.OrderSummary createOrder(Long userId, OrderCriteria.Create cr
                             order.getOriginalTotalPrice()));
         }
 
+        // 4. 포인트 차감
         userService.deductPoint(userId, order.getTotalPrice());
 
-        return OrderResult.OrderSummary.from(order);
+        return order;
     }
 
     @Transactional(readOnly = true)
@@ -84,31 +103,25 @@ public OrderResult.OrderDetail getOrderDetail(Long orderId) {
         return OrderResult.OrderDetail.from(orderService.getById(orderId));
     }
 
-    @Retryable(
-            retryFor = ObjectOptimisticLockingFailureException.class,
-            maxAttempts = 5,
-            backoff = @Backoff(delay = 50, random = true))
     @Transactional
     public void cancelMyOrderItem(Long userId, Long orderId, Long orderItemId) {
-        OrderModel order = orderService.getByIdAndUserId(orderId, userId);
+        OrderModel order = orderService.getByIdWithLock(orderId);
+        order.validateOwner(userId);
         OrderInfo.CancelledItem cancelledItem = orderService.cancelItem(order, orderItemId);
         productService.increaseStock(cancelledItem.productId(), cancelledItem.quantity());
         if (cancelledItem.orderFullyCancelled()) {
             couponService.restoreByOrderId(orderId);
         }
     }
 
-    @Retryable(
-            retryFor = ObjectOptimisticLockingFailureException.class,
-            maxAttempts = 5,
-            backoff = @Backoff(delay = 50, random = true))
     @Transactional
     public void cancelOrderItem(Long orderId, Long orderItemId) {
-        OrderModel order = orderService.getById(orderId);
+        OrderModel order = orderService.getByIdWithLock(orderId);
         OrderInfo.CancelledItem cancelledItem = orderService.cancelItem(order, orderItemId);
         productService.increaseStock(cancelledItem.productId(), cancelledItem.quantity());
         if (cancelledItem.orderFullyCancelled()) {
             couponService.restoreByOrderId(orderId);
         }
     }
+
 }

apps/commerce-api/src/main/java/com/loopers/application/order/OrderPointHandler.java

@@ -0,0 +1,33 @@
+package com.loopers.application.order;
+
+import com.loopers.domain.order.event.OrderCompletedEvent;
+import com.loopers.domain.user.UserService;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+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;
+
+@Slf4j
+@Component
+@RequiredArgsConstructor
+public class OrderPointHandler {
+
+    private final UserService userService;
+
+    @Transactional(propagation = Propagation.REQUIRES_NEW)
+    @TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)
+    public void handle(OrderCompletedEvent event) {
+        try {
+            long pointAmount = (long) (event.totalPrice() * 0.02);
+            if (pointAmount > 0) {
+                userService.addPoint(event.userId(), pointAmount);
+            }
+        } catch (Exception e) {
+            log.warn("[OrderPoint] 포인트 적립 실패 — orderId={}, userId={}",
+                    event.orderId(), event.userId(), e);
+        }
+    }
+}

apps/commerce-api/src/main/java/com/loopers/application/order/dto/OrderCriteria.java

@@ -1,15 +1,24 @@
 package com.loopers.application.order.dto;
 
+import com.loopers.domain.payment.CardType;
 import com.loopers.domain.product.dto.ProductCommand;
 import java.time.ZonedDateTime;
 import java.util.List;
 
 public class OrderCriteria {
 
-    public record Create(List<CreateItem> items, Long ownedCouponId) {
+    public record Create(
+            List<CreateItem> items,
+            Long ownedCouponId,
+            CardType cardType,
+            String cardNo) {
 
         public Create(List<CreateItem> items) {
-            this(items, null);
+            this(items, null, null, null);
+        }
+
+        public Create(List<CreateItem> items, Long ownedCouponId) {
+            this(items, ownedCouponId, null, null);
         }
 
         public List<ProductCommand.StockDeduction> toStockDeductions() {