feat : 7주 과제

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"))

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

@@ -4,8 +4,10 @@
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
 import org.springframework.boot.context.properties.ConfigurationPropertiesScan;
+import org.springframework.scheduling.annotation.EnableScheduling;
 import java.util.TimeZone;
 
+@EnableScheduling
 @ConfigurationPropertiesScan
 @SpringBootApplication
 public class CommerceApiApplication {

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

@@ -1,25 +1,38 @@
 package com.loopers.application.coupon;
 
+import com.loopers.application.coupon.dto.CouponIssueRequestResDto;
 import com.loopers.application.coupon.dto.FindMyCouponResDto;
 import com.loopers.application.coupon.dto.IssueCouponResDto;
+import com.loopers.domain.coupon.model.CouponIssueRequest;
+import com.loopers.domain.coupon.model.FirstComeCoupon;
 import com.loopers.domain.coupon.model.UserCoupon;
 import com.loopers.domain.coupon.model.UserCouponItem;
+import com.loopers.domain.coupon.repository.CouponIssueRequestRepository;
 import com.loopers.domain.coupon.service.CouponService;
+import com.loopers.domain.coupon.service.FirstComeCouponService;
 import com.loopers.domain.member.model.Member;
 import com.loopers.domain.member.service.MemberService;
+import com.loopers.support.error.CoreException;
+import com.loopers.support.error.ErrorType;
 import lombok.RequiredArgsConstructor;
 import org.springframework.data.domain.Page;
 import org.springframework.data.domain.Pageable;
+import org.springframework.kafka.core.KafkaTemplate;
 import org.springframework.stereotype.Component;
 import org.springframework.transaction.annotation.Transactional;
 
+import java.util.Map;
+
 @RequiredArgsConstructor
 @Component
 @Transactional(readOnly = true)
 public class CouponFacade {
 
     private final CouponService couponService;
     private final MemberService memberService;
+    private final FirstComeCouponService firstComeCouponService;
+    private final CouponIssueRequestRepository couponIssueRequestRepository;
+    private final KafkaTemplate<Object, Object> kafkaTemplate;
 
     @Transactional(rollbackFor = Exception.class)
     public IssueCouponResDto issueCoupon(String loginId, String password, Long couponTemplateId) {
@@ -33,4 +46,37 @@ public Page<FindMyCouponResDto> getMyCoupons(String loginId, String password, Pa
         Page<UserCouponItem> items = couponService.getUserCouponsWithTemplate(member.getId(), pageable);
         return items.map(FindMyCouponResDto::from);
     }
+
+    @Transactional(rollbackFor = Exception.class)
+    public CouponIssueRequestResDto requestFirstComeIssue(String loginId, String password, Long couponTemplateId) {
+        Member member = memberService.findMember(loginId, password);
+        FirstComeCoupon fcCoupon = firstComeCouponService.getByTemplateId(couponTemplateId);
+
+        firstComeCouponService.addToQueue(fcCoupon, member.getId());
+        try {
+            CouponIssueRequest request = couponIssueRequestRepository.save(
+                    CouponIssueRequest.create(couponTemplateId, member.getId()));
+
+            kafkaTemplate.send("coupon-issue-requests",
+                    String.valueOf(couponTemplateId),
+                    Map.of("requestId", request.getId(),
+                            "couponTemplateId", couponTemplateId,
+                            "memberId", member.getId()));
+
+            return CouponIssueRequestResDto.from(request);
+        } catch (Exception e) {
+            firstComeCouponService.removeFromQueue(couponTemplateId, member.getId());
+            throw e;
+        }
+    }
+
+    public CouponIssueRequestResDto getIssueRequestStatus(String loginId, String password, Long requestId) {
+        Member member = memberService.findMember(loginId, password);
+        CouponIssueRequest request = couponIssueRequestRepository.findById(requestId)
+                .orElseThrow(() -> new CoreException(ErrorType.NOT_FOUND, "존재하지 않는 발급 요청입니다."));
+        if (!request.getMemberId().equals(member.getId())) {
+            throw new CoreException(ErrorType.NOT_FOUND, "존재하지 않는 발급 요청입니다.");
+        }
+        return CouponIssueRequestResDto.from(request);
+    }
 }

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

@@ -0,0 +1,11 @@
+package com.loopers.application.coupon.dto;
+
+import com.loopers.domain.coupon.model.CouponIssueRequest;
+import com.loopers.domain.coupon.model.CouponIssueStatus;
+
+public record CouponIssueRequestResDto(Long requestId, Long couponTemplateId, CouponIssueStatus status) {
+
+    public static CouponIssueRequestResDto from(CouponIssueRequest request) {
+        return new CouponIssueRequestResDto(request.getId(), request.getCouponTemplateId(), request.getStatus());
+    }
+}

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

@@ -0,0 +1,61 @@
+package com.loopers.application.event;
+
+import com.loopers.domain.event.FavoriteAddedEvent;
+import com.loopers.domain.event.FavoriteRemovedEvent;
+import com.loopers.domain.outbox.model.OutboxEvent;
+import com.loopers.domain.outbox.model.OutboxEventType;
+import com.loopers.domain.outbox.repository.OutboxEventRepository;
+import com.loopers.domain.product.service.ProductService;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.ObjectMapper;
+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
+@RequiredArgsConstructor
+@Component
+public class FavoriteEventListener {
+
+    private final ProductService productService;
+    private final OutboxEventRepository outboxEventRepository;
+    private final ObjectMapper objectMapper;
+
+    @TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)
+    @Transactional(propagation = Propagation.REQUIRES_NEW)
+    public void onFavoriteAdded(FavoriteAddedEvent event) {
+        log.info("좋아요 집계 처리 - productId: {}, memberId: {}", event.productId(), event.memberId());
+        productService.increaseLikeCount(event.productId());
+        outboxEventRepository.save(OutboxEvent.create(
+                OutboxEventType.FAVORITE_ADDED,
+                String.valueOf(event.productId()),
+                toJson(event)
+        ));
+        log.info("유저 행동 로깅 - memberId: {}, action: FAVORITE_ADD, targetId: {}", event.memberId(), event.productId());
+    }
+
+    @TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)
+    @Transactional(propagation = Propagation.REQUIRES_NEW)
+    public void onFavoriteRemoved(FavoriteRemovedEvent event) {
+        log.info("좋아요 집계 해제 처리 - productId: {}, memberId: {}", event.productId(), event.memberId());
+        productService.decreaseLikeCount(event.productId());
+        outboxEventRepository.save(OutboxEvent.create(
+                OutboxEventType.FAVORITE_REMOVED,
+                String.valueOf(event.productId()),
+                toJson(event)
+        ));
+        log.info("유저 행동 로깅 - memberId: {}, action: FAVORITE_REMOVE, targetId: {}", event.memberId(), event.productId());
+    }
+
+    private String toJson(Object obj) {
+        try {
+            return objectMapper.writeValueAsString(obj);
+        } catch (JsonProcessingException e) {
+            throw new RuntimeException("이벤트 직렬화 실패", e);
+        }
+    }
+}

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

@@ -0,0 +1,73 @@
+package com.loopers.application.event;
+
+import com.loopers.domain.coupon.service.CouponService;
+import com.loopers.domain.event.OrderCreatedEvent;
+import com.loopers.domain.event.OrderExpiredEvent;
+import com.loopers.domain.order.model.OrderProduct;
+import com.loopers.domain.order.service.OrderProductService;
+import com.loopers.domain.outbox.model.OutboxEvent;
+import com.loopers.domain.outbox.model.OutboxEventType;
+import com.loopers.domain.outbox.repository.OutboxEventRepository;
+import com.loopers.domain.product.service.ProductService;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.ObjectMapper;
+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;
+
+import java.util.List;
+
+@Slf4j
+@RequiredArgsConstructor
+@Component
+public class OrderEventListener {
+
+    private final OutboxEventRepository outboxEventRepository;
+    private final OrderProductService orderProductService;
+    private final ProductService productService;
+    private final CouponService couponService;
+    private final ObjectMapper objectMapper;
+
+    @TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)
+    @Transactional(propagation = Propagation.REQUIRES_NEW)
+    public void onOrderCreated(OrderCreatedEvent event) {
+        log.info("주문 생성 이벤트 - orderId: {}, memberId: {}, totalPrice: {}", event.orderId(), event.memberId(), event.totalPrice());
+        outboxEventRepository.save(OutboxEvent.create(
+                OutboxEventType.ORDER_CREATED,
+                String.valueOf(event.orderId()),
+                toJson(event)
+        ));
+        log.info("유저 행동 로깅 - memberId: {}, action: ORDER_CREATE, targetId: {}", event.memberId(), event.orderId());
+    }
+
+    @TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)
+    @Transactional(propagation = Propagation.REQUIRES_NEW)
+    public void onOrderExpired(OrderExpiredEvent event) {
+        log.info("주문 만료 처리 - orderId: {}", event.orderId());
+        try {
+            List<OrderProduct> products = orderProductService.findByOrderId(event.orderId());
+            for (OrderProduct op : products) {
+                productService.increaseStockAtomic(op.getProductId(), op.getQuantity().value());
+            }
+            if (event.userCouponId() != null) {
+                couponService.restoreUserCoupon(event.userCouponId());
+            }
+            log.info("주문 만료 복원 완료 - orderId: {}, 재고 복원 {}건, 쿠폰 복원: {}",
+                    event.orderId(), products.size(), event.userCouponId() != null);
+        } catch (Exception e) {
+            log.error("주문 만료 복원 실패 - orderId: {}, 수동 확인 필요", event.orderId(), e);
+        }
+    }
+
+    private String toJson(Object obj) {
+        try {
+            return objectMapper.writeValueAsString(obj);
+        } catch (JsonProcessingException e) {
+            throw new RuntimeException("이벤트 직렬화 실패", e);
+        }
+    }
+}

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

@@ -0,0 +1,38 @@
+package com.loopers.application.event;
+
+import com.loopers.domain.event.OrderExpiredEvent;
+import com.loopers.domain.order.OrderStatus;
+import com.loopers.domain.order.model.Orders;
+import com.loopers.domain.order.service.OrderService;
+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;
+
+@Slf4j
+@RequiredArgsConstructor
+@Component
+public class OrderExpireScheduler {
+
+    private final OrderService orderService;
+    private final ApplicationEventPublisher eventPublisher;
+
+    @Scheduled(fixedDelay = 60000)
+    @Transactional
+    public void expireUnpaidOrders() {
+        List<Orders> expiredOrders = orderService.findExpiredOrders();
+        if (expiredOrders.isEmpty()) {
+            return;
+        }
+
+        for (Orders order : expiredOrders) {
+            orderService.updateOrderStatus(order.getId(), OrderStatus.CANCELLED);
+            eventPublisher.publishEvent(new OrderExpiredEvent(order.getId(), order.getUserCouponId()));
+            log.info("주문 만료 처리 - orderId: {}", order.getId());
+        }
+    }
+}

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

@@ -0,0 +1,49 @@
+package com.loopers.application.event;
+
+import com.loopers.domain.outbox.model.OutboxEvent;
+import com.loopers.domain.outbox.model.OutboxEventType;
+import com.loopers.domain.outbox.repository.OutboxEventRepository;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.kafka.core.KafkaTemplate;
+import org.springframework.scheduling.annotation.Scheduled;
+import org.springframework.stereotype.Component;
+
+import java.util.List;
+
+@Slf4j
+@RequiredArgsConstructor
+@Component
+public class OutboxRelay {
+
+    private final OutboxEventRepository outboxEventRepository;
+    private final KafkaTemplate<Object, Object> kafkaTemplate;
+
+    @Scheduled(fixedDelay = 1000)
+    public void relay() {
+        List<OutboxEvent> events = outboxEventRepository.findByStatusInit();
+        if (events.isEmpty()) {
+            return;
+        }
+
+        for (OutboxEvent event : events) {
+            String topic = resolveTopic(event.getEventType());
+            try {
+                kafkaTemplate.send(topic, event.getAggregateId(), event.getPayload()).get();
+                event.markPublished();
+                log.info("Outbox 이벤트 발행 - topic: {}, key: {}, eventType: {}", topic, event.getAggregateId(), event.getEventType());
+            } catch (Exception e) {
+                event.markFailed();
+                log.error("Outbox 이벤트 발행 실패 - eventId: {}", event.getId(), e);
+            }
+            outboxEventRepository.save(event);
+        }
+    }
+
+    private String resolveTopic(OutboxEventType eventType) {
+        return switch (eventType) {
+            case FAVORITE_ADDED, FAVORITE_REMOVED -> "catalog-events";
+            case ORDER_CREATED, PAYMENT_COMPLETED -> "order-events";
+        };
+    }
+}