Merge pull request #97 from rnqhstmd/round4

[volume-4] 트랜잭션 및 동시성 구현

Author: rnqhstmd

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

@@ -1,5 +1,7 @@
 package com.loopers.application.order;
 
+import com.loopers.domain.coupon.Coupon;
+import com.loopers.domain.coupon.CouponService;
 import com.loopers.domain.order.Order;
 import com.loopers.domain.order.OrderService;
 import com.loopers.domain.point.PointService;
@@ -10,6 +12,7 @@
 import com.loopers.support.error.CoreException;
 import com.loopers.support.error.ErrorType;
 import lombok.RequiredArgsConstructor;
+import org.springframework.orm.ObjectOptimisticLockingFailureException;
 import org.springframework.stereotype.Component;
 import org.springframework.transaction.annotation.Transactional;
 
@@ -27,16 +30,18 @@ public class OrderFacade {
     private final UserService userService;
     private final ProductService productService;
     private final PointService pointService;
+    private final CouponService couponService;
 
     @Transactional
     public OrderInfo placeOrder(OrderPlaceCommand command) {
         User user = userService.getUserByUserId(command.userId());
 
         List<Long> productIds = command.items().stream()
                 .map(OrderPlaceCommand.OrderItemCommand::productId)
+                .sorted()
                 .toList();
 
-        List<Product> products = productService.getProductsByIds(productIds);
+        List<Product> products = productService.getProductsByIdsWithPessimisticLock(productIds);
         Map<Long, Product> productMap = products.stream()
                 .collect(Collectors.toMap(Product::getId, Function.identity()));
 
@@ -50,19 +55,27 @@ public OrderInfo placeOrder(OrderPlaceCommand command) {
         }
 
         Long totalAmount = order.getTotalAmountValue();
-        pointService.usePoint(user.getUserIdValue(), totalAmount);
+        Long discountAmount = 0L;
+        Long couponId = command.couponId();
 
-        order.completePayment();
+        if (couponId != null) {
+            Coupon coupon = couponService.getCouponWithOptimisticLock(couponId);
+            couponService.validateCouponUsable(coupon, user);
+
+            discountAmount = coupon.calculateDiscount(totalAmount);
+            coupon.use();
+            couponService.save(coupon);
+        }
+        long finalAmount = totalAmount - discountAmount;
+        pointService.usePointWithLock(user.getUserIdValue(), finalAmount);
 
+        order.completePayment();
         Order savedOrder = orderService.save(order);
 
         return OrderInfo.from(savedOrder);
     }
 
-    private void validateAndDecreaseStock(
-            List<OrderPlaceCommand.OrderItemCommand> items,
-            Map<Long, Product> productMap
-    ) {
+    private void validateAndDecreaseStock(List<OrderPlaceCommand.OrderItemCommand> items, Map<Long, Product> productMap) {
         for (OrderPlaceCommand.OrderItemCommand item : items) {
             Product product = productMap.get(item.productId());
 

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

@@ -4,7 +4,8 @@
 
 public record OrderPlaceCommand(
         String userId,
-        List<OrderItemCommand> items
+        List<OrderItemCommand> items,
+        Long couponId
 ) {
     public record OrderItemCommand(
             Long productId,

apps/commerce-api/src/main/java/com/loopers/domain/coupon/Coupon.java

@@ -0,0 +1,90 @@
+package com.loopers.domain.coupon;
+
+import com.loopers.domain.BaseEntity;
+import com.loopers.domain.user.User;
+import com.loopers.support.error.CoreException;
+import com.loopers.support.error.ErrorType;
+import jakarta.persistence.*;
+import lombok.AccessLevel;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+
+@Entity
+@Getter
+@Table(name = "coupons")
+@NoArgsConstructor(access = AccessLevel.PROTECTED)
+public class Coupon extends BaseEntity {
+
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "user_id", nullable = false)
+    private User user;
+
+    @Column(name = "name", nullable = false)
+    private String name;
+
+    @Enumerated(EnumType.STRING)
+    @Column(name = "discount_type", nullable = false)
+    private DiscountType discountType;
+
+    @Column(name = "discount_value", nullable = false)
+    private Long discountValue;
+
+    @Column(name = "is_used", nullable = false)
+    private Boolean isUsed = false;
+
+    @Version
+    private Long version;
+
+    private Coupon(User user, String name, DiscountType discountType, Long discountValue) {
+        validateFields(user, name, discountType, discountValue);
+        this.user = user;
+        this.name = name;
+        this.discountType = discountType;
+        this.discountValue = discountValue;
+        this.isUsed = false;
+    }
+
+    public static Coupon create(User user, String name, DiscountType discountType, Long discountValue) {
+        return new Coupon(user, name, discountType, discountValue);
+    }
+
+    public Long calculateDiscount(Long originalAmount) {
+        if (Boolean.TRUE.equals(this.isUsed)) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "이미 사용된 쿠폰입니다.");
+        }
+
+        return switch (discountType) {
+            case FIXED_AMOUNT -> Math.min(discountValue, originalAmount);
+            case PERCENTAGE -> (originalAmount * discountValue) / 100;
+        };
+    }
+
+    public void use() {
+        if (Boolean.TRUE.equals(this.isUsed)) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "이미 사용된 쿠폰입니다.");
+        }
+        this.isUsed = true;
+    }
+
+    public boolean canUse() {
+        return !this.isUsed;
+    }
+
+    private void validateFields(User user, String name, DiscountType discountType, Long discountValue) {
+        if (user == null) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "사용자는 필수입니다.");
+        }
+        if (name == null || name.isBlank()) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "쿠폰명은 필수입니다.");
+        }
+        if (discountType == null) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "할인 타입은 필수입니다.");
+        }
+        if (discountValue == null || discountValue <= 0) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "할인 값은 0보다 커야 합니다.");
+        }
+        if (discountType == DiscountType.PERCENTAGE && discountValue > 100) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "정률 할인은 100% 이하여야 합니다.");
+        }
+    }
+}

apps/commerce-api/src/main/java/com/loopers/domain/coupon/CouponRepository.java

@@ -0,0 +1,13 @@
+package com.loopers.domain.coupon;
+
+import com.loopers.domain.user.User;
+
+import java.util.Optional;
+
+public interface CouponRepository {
+    Coupon save(Coupon coupon);
+    Optional<Coupon> findById(Long id);
+    Optional<Coupon> findByIdWithOptimisticLock(Long id);
+    Optional<Coupon> findByIdWithPessimisticLock(Long id);
+    Optional<Coupon> findByIdAndUser(Long id, User user);
+}

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

@@ -0,0 +1,42 @@
+package com.loopers.domain.coupon;
+
+import com.loopers.domain.user.User;
+import com.loopers.support.error.CoreException;
+import com.loopers.support.error.ErrorType;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+@Service
+@RequiredArgsConstructor
+@Transactional(readOnly = true)
+public class CouponService {
+
+    private final CouponRepository couponRepository;
+
+    @Transactional
+    public Coupon getCouponWithOptimisticLock(Long id) {
+        return couponRepository.findByIdWithOptimisticLock(id)
+                .orElseThrow(() -> new CoreException(ErrorType.NOT_FOUND, "쿠폰을 찾을 수 없습니다."));
+    }
+
+    @Transactional
+    public Coupon getCouponWithPessimisticLock(Long id) {
+        return couponRepository.findByIdWithPessimisticLock(id)
+                .orElseThrow(() -> new CoreException(ErrorType.NOT_FOUND, "쿠폰을 찾을 수 없습니다."));
+    }
+
+    public void validateCouponUsable(Coupon coupon, User user) {
+        if (!coupon.getUser().equals(user)) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "본인의 쿠폰만 사용할 수 있습니다.");
+        }
+        if (!coupon.canUse()) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "사용할 수 없는 쿠폰입니다.");
+        }
+    }
+
+    @Transactional
+    public Coupon save(Coupon coupon) {
+        return couponRepository.save(coupon);
+    }
+}

apps/commerce-api/src/main/java/com/loopers/domain/coupon/DiscountType.java

@@ -0,0 +1,6 @@
+package com.loopers.domain.coupon;
+
+public enum DiscountType {
+    FIXED_AMOUNT, // 정액
+    PERCENTAGE // 정률
+}

apps/commerce-api/src/main/java/com/loopers/domain/like/Like.java

@@ -10,7 +10,12 @@
 
 @Entity
 @Getter
-@Table(name = "likes")
+@Table(name = "likes", uniqueConstraints = {
+        @UniqueConstraint(
+                name = "uk_user_product",
+                columnNames = {"user_id", "product_id"}
+        )
+})
 @NoArgsConstructor(access = AccessLevel.PROTECTED)
 public class Like extends BaseEntity {
 
@@ -26,6 +31,7 @@ private Like(User user, Product product) {
         this.user = user;
         this.product = product;
     }
+
     public static Like create(User user, Product product) {
         return new Like(user, product);
     }

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

@@ -3,6 +3,7 @@
 import com.loopers.domain.product.Product;
 import com.loopers.domain.user.User;
 import lombok.RequiredArgsConstructor;
+import org.springframework.dao.DataIntegrityViolationException;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
@@ -18,11 +19,12 @@ public class LikeService {
 
     @Transactional
     public void addLike(User user, Product product) {
-        if (likeRepository.existsByUserAndProduct(user, product)) {
-            return;
-        }
         Like like = Like.create(user, product);
-        likeRepository.save(like);
+        // 중복 좋아요 방지를 위해 예외 무시
+        try {
+            likeRepository.save(like);
+        } catch (DataIntegrityViolationException ignored) {
+        }
     }
 
     @Transactional

apps/commerce-api/src/main/java/com/loopers/domain/order/OrderRepository.java

@@ -1,12 +1,11 @@
 package com.loopers.domain.order;
 
-import com.loopers.domain.user.User;
 
 import java.util.List;
 import java.util.Optional;
 
 public interface OrderRepository {
     Order save(Order order);
-    Optional<Order> findByIdAndUser(Long orderId, User user);
-    List<Order> findAllByUser(User user);
+    Optional<Order> findByIdAndUser(Long orderId, Long userId);
+    List<Order> findAllByUser(Long userId);
 }

apps/commerce-api/src/main/java/com/loopers/domain/order/OrderService.java

@@ -21,11 +21,11 @@ public Order save(Order order) {
     }
 
     public List<Order> getOrdersByUser(User user) {
-        return orderRepository.findAllByUser(user);
+        return orderRepository.findAllByUser(user.getId());
     }
 
     public Order getOrderByIdAndUser(Long orderId, User user) {
-        return orderRepository.findByIdAndUser(orderId, user)
+        return orderRepository.findByIdAndUser(orderId, user.getId())
                 .orElseThrow(() -> new CoreException(ErrorType.NOT_FOUND, "주문을 찾을 수 없습니다."));
     }
 }