feat: Kafka 기반 주문 이벤트 발행

Application Event에서 Kafka 기반 이벤트 방식으로 변경

Author: Kimjipang

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

@@ -1,22 +1,23 @@
 package com.loopers.application.order;
 
 import com.loopers.application.orderitem.OrderItemInfo;
-import com.loopers.application.product.UserActionEvent;
 import com.loopers.domain.coupon.Coupon;
 import com.loopers.domain.coupon.CouponRepository;
 import com.loopers.domain.order.Order;
 import com.loopers.domain.order.OrderRepository;
 import com.loopers.domain.orderitem.OrderItem;
 import com.loopers.domain.orderitem.OrderItemRepository;
+import com.loopers.domain.outbox.AggregateType;
+import com.loopers.domain.outbox.OutboxEvent;
+import com.loopers.domain.outbox.OutboxRepository;
+import com.loopers.domain.outbox.OutboxType;
 import com.loopers.domain.product.Product;
 import com.loopers.domain.product.ProductRepository;
 import com.loopers.domain.user.UserRepository;
 import com.loopers.interfaces.api.order.OrderV1Dto;
-import com.loopers.interfaces.api.payment.PaymentV1Dto;
 import com.loopers.support.error.CoreException;
 import com.loopers.support.error.ErrorType;
 import lombok.RequiredArgsConstructor;
-import org.springframework.context.ApplicationEventPublisher;
 import org.springframework.stereotype.Component;
 import org.springframework.transaction.annotation.Transactional;
 
@@ -31,7 +32,7 @@ public class OrderFacade {
     private final UserRepository userRepository;
     private final ProductRepository productRepository;
     private final CouponRepository couponRepository;
-    private final ApplicationEventPublisher publisher;
+    private final OutboxRepository outBoxRepository;
 
     @Transactional
     public OrderResultInfo createOrder(OrderV1Dto.OrderRequest request) {
@@ -50,31 +51,31 @@ public OrderResultInfo createOrder(OrderV1Dto.OrderRequest request) {
         List<OrderV1Dto.OrderItemRequest> orderItemRequests = request.orderItems();
 
         List<OrderItem> orderItems = orderItemRequests.stream()
-                        .map(item -> {
-                            // 상품 검증
-                            Long productId = item.productId();
-                            Product product = productRepository.findById(productId).orElseThrow(
-                                    () -> new CoreException(ErrorType.NOT_FOUND, "존재하는 상품이 아닙니다.")
-                            );
-
-                            if (product.getStock() < item.quantity()) {
-                                throw new CoreException(ErrorType.BAD_REQUEST, product.getName() + " 상품의 재고가 부족합니다.");
-                            }
- 
-                            product.decreaseStock(item.quantity());
-
-                            OrderItem orderItem = item.toEntity(
-                                    null,
-                                    product.getPrice().multiply(BigDecimal.valueOf(item.quantity()))
-                            );
-                            return orderItem;
-
-                        })
-                                .toList();
+                .map(item -> {
+                    // 상품 검증
+                    Long productId = item.productId();
+                    Product product = productRepository.findById(productId).orElseThrow(
+                            () -> new CoreException(ErrorType.NOT_FOUND, "존재하는 상품이 아닙니다.")
+                    );
+
+                    if (product.getStock() < item.quantity()) {
+                        throw new CoreException(ErrorType.BAD_REQUEST, product.getName() + " 상품의 재고가 부족합니다.");
+                    }
+
+                    product.decreaseStock(item.quantity());
+
+                    OrderItem orderItem = item.toEntity(
+                            null,
+                            product.getPrice().multiply(BigDecimal.valueOf(item.quantity()))
+                    );
+                    return orderItem;
+
+                })
+                .toList();
 
         BigDecimal totalPrice = orderItems.stream()
-                        .map(OrderItem::getOrderPrice)
-                        .reduce(BigDecimal.ZERO, BigDecimal::add);
+                .map(OrderItem::getOrderPrice)
+                .reduce(BigDecimal.ZERO, BigDecimal::add);
 
         Long couponId = request.couponId();
 
@@ -92,27 +93,28 @@ public OrderResultInfo createOrder(OrderV1Dto.OrderRequest request) {
                 .multiply(BigDecimal.valueOf(100 - rate))
                 .divide(BigDecimal.valueOf(100));
 
-        publisher.publishEvent(new OrderCreatedEvent(couponId, null, null, null, null, null));
+        coupon.useCoupon();
 
         Order order = request.toEntity(totalPrice);
         Order saved = orderRepository.save(order);
 
         orderItems.forEach(item -> item.assignOrderId(saved.getId()));
-        orderItemRepository.saveAll(orderItems);
+        List<OrderItem> savedOrderItems = orderItemRepository.saveAll(orderItems);
+
+        savedOrderItems.forEach(orderItem -> {
+            OutboxEvent outboxEvent = OutboxEvent.of(
+                    AggregateType.PRODUCT,
+                    orderItem.getProductId(),
+                    OutboxType.PRODUCT_SALES
+            );
 
-        List<OrderItemInfo> orderItemInfos = orderItems.stream()
+            outBoxRepository.save(outboxEvent);
+        });
+
+        List<OrderItemInfo> orderItemInfos = savedOrderItems.stream()
                 .map(orderItem -> OrderItemInfo.from(orderItem, orderItem.getOrderPrice()))
                 .toList();
 
-        publisher.publishEvent(new OrderCreatedEvent(
-                couponId,
-                "1351039135",
-                PaymentV1Dto.CardTypeDto.HYUNDAI,
-                "1234-5678-9814-1451",
-                100000L,
-                "http://localhost:8080/api/v1/examples/callback"
-        ));
-
         return new OrderResultInfo(OrderInfo.from(saved), orderItemInfos);
     }
 }

apps/commerce-api/src/main/java/com/loopers/infrastructure/outbox/KafkaOutboxPublisher.java

@@ -21,7 +21,7 @@ public class KafkaOutboxPublisher {
     @Scheduled(fixedDelayString = "60000")
     @Transactional
     public void publishProductViewed() {
-        List<OutboxEvent> events = outboxRepository.findPending(2);
+        List<OutboxEvent> events = outboxRepository.findPending(10);
 
         for (OutboxEvent event : events) {
             OutboxType type = event.getEventType();
@@ -34,6 +34,10 @@ else if (type.equals(OutboxType.PRODUCT_LIKED)) {
                 kafkaTemplate.send("product-liked", String.valueOf(event.getAggregateId()), event);
             }
 
+            else if (type.equals(OutboxType.PRODUCT_SALES)) {
+                kafkaTemplate.send("product-sales", String.valueOf(event.getAggregateId()), event);
+            }
+
             event.markAsProcessed();
         }