Merge pull request #107 from yeonjiyeon/feature/week4

round4 - 트랜잭션 및 동시성 구현

Author: yeonjiyeon

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

@@ -2,27 +2,80 @@
 
 import com.loopers.domain.like.Like;
 import com.loopers.domain.like.LikeService;
+import com.loopers.domain.product.Product;
 import com.loopers.domain.product.ProductService;
-import com.loopers.domain.user.UserService;
+import java.util.Optional;
 import lombok.RequiredArgsConstructor;
+import org.springframework.orm.ObjectOptimisticLockingFailureException;
 import org.springframework.stereotype.Component;
+import org.springframework.transaction.support.TransactionTemplate;
 
 @RequiredArgsConstructor
 @Component
 public class LikeFacade {
 
-  private final UserService userService;
   private final ProductService productService;
   private final LikeService likeService;
+  private final TransactionTemplate transactionTemplate;
+
+  private static final int RETRY_COUNT = 30;
 
   public LikeInfo like(long userId, long productId) {
-    Like like = likeService.like(userId, productId);
-    long totalLikes = likeService.countLikesByProductId(productId);
-    return LikeInfo.from(like, totalLikes);
+    Optional<Like> existingLike = likeService.findLike(userId, productId);
+
+
+    if (existingLike.isPresent()) {
+      Product product = productService.getProduct(productId);
+      return LikeInfo.from(existingLike.get(), product.getLikeCount());
+    }
+
+    for (int i = 0; i < RETRY_COUNT; i++) {
+      try {
+
+        Like newLike = likeService.save(userId, productId);
+        int updatedLikeCount = productService.increaseLikeCount(productId);
+
+        return LikeInfo.from(newLike, updatedLikeCount);
+      } catch (ObjectOptimisticLockingFailureException e) {
+        if (i == RETRY_COUNT - 1) {
+          throw e;
+        }
+        sleep(50);
+      }
+    }
+
+    throw new IllegalStateException("좋아요 처리 재시도 횟수를 초과했습니다.");
+  }
+
+  public int unLike(long userId, long productId) {
+    for (int i = 0; i < RETRY_COUNT; i++) {
+      try {
+
+        return transactionTemplate.execute(status -> {
+
+          likeService.unLike(userId, productId);
+
+          return productService.decreaseLikeCount(productId);
+
+        });
+
+      } catch (ObjectOptimisticLockingFailureException e) {
+
+        if (i == RETRY_COUNT - 1) {
+          throw e;
+        }
+        sleep(50);
+      }
+    }
+    throw new IllegalStateException("싫어요 처리 재시도 횟수를 초과했습니다.");
   }
 
-  public long unLike(long userId, long productId) {
-   likeService.unLike(userId, productId);
-    return likeService.countLikesByProductId(productId);
+  private void sleep(long millis) {
+    try {
+      Thread.sleep(millis);
+    } catch (InterruptedException e) {
+      Thread.currentThread().interrupt();
+      throw new RuntimeException(e);
+    }
   }
 }

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

@@ -1,15 +1,15 @@
 package com.loopers.application.order;
 
 import com.loopers.domain.order.Order;
+import com.loopers.domain.order.OrderCommand.Item;
+import com.loopers.domain.order.OrderCommand.PlaceOrder;
 import com.loopers.domain.order.OrderItem;
 import com.loopers.domain.order.OrderService;
 import com.loopers.domain.point.PointService;
 import com.loopers.domain.product.Product;
 import com.loopers.domain.product.ProductService;
 import com.loopers.domain.user.User;
 import com.loopers.domain.user.UserService;
-import com.loopers.interfaces.order.OrderV1Dto.OrderItemRequest;
-import com.loopers.interfaces.order.OrderV1Dto.OrderRequest;
 import com.loopers.support.error.CoreException;
 import com.loopers.support.error.ErrorType;
 import java.util.List;
@@ -21,40 +21,37 @@
 
 @RequiredArgsConstructor
 @Component
+@Transactional
 public class OrderFacade {
+
   private final ProductService productService;
   private final UserService userService;
   private final OrderService orderService;
   private final PointService pointService;
 
   @Transactional
-  public OrderInfo placeOrder(String userId, OrderRequest request) {
-
-    if (userId == null) {
-      throw new CoreException(ErrorType.BAD_REQUEST, "사용자 ID는 필수입니다.");
-    }
+  public OrderInfo placeOrder(PlaceOrder command) {
 
-    User user = userService.getUser(userId);
+    User user = userService.findByIdWithLock(command.userId())
+        .orElseThrow(() -> new CoreException(ErrorType.NOT_FOUND, "유저를 찾을 수 없습니다."));
 
-    List<Long> productIds = request.items().stream()
-        .map(OrderItemRequest::productId)
+    List<Long> productIds = command.items().stream()
+        .map(Item::productId)
         .toList();
 
     List<Product> products = productService.getProducts(productIds);
-    long totalAmount = orderService.calculateTotal(products, request.items());
-
 
-    productService.deductStock(products, request.items());
-
-    pointService.deductPoint(user.getId(), totalAmount);
-
-    List<OrderItem> orderItems = buildOrderItems(products, request.items());
+    List<OrderItem> orderItems = buildOrderItems(products, command.items());
     Order order = orderService.createOrder(user.getId(), orderItems);
+    long totalAmount = order.getTotalAmount().getValue();
+
+    productService.deductStock(products, orderItems);
+    pointService.deductPoint(user, totalAmount);
 
     return OrderInfo.from(order);
   }
 
-  private List<OrderItem> buildOrderItems(List<Product> products, List<OrderItemRequest> items) {
+  private List<OrderItem> buildOrderItems(List<Product> products, List<Item> items) {
 
     Map<Long, Product> productMap = products.stream()
         .collect(Collectors.toMap(Product::getId, p -> p));

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

@@ -17,7 +17,7 @@ public static OrderInfo from(Order order) {
         order.getId(),
         order.getUserId(),
         order.getOrderItems().stream().map(OrderItemInfo::from).toList(),
-        order.calculateTotalAmount()
+        order.getTotalAmount().getValue()
     );
   }
 

apps/commerce-api/src/main/java/com/loopers/application/product/ProductInfo.java

@@ -7,14 +7,16 @@ public record ProductInfo(
     Long id,
     String name,
     Money price,
-    String brandName
+    String brandName,
+    int likeCount
 ) {
   public static ProductInfo from(Product product) {
     return new ProductInfo(
         product.getId(),
         product.getName(),
         product.getPrice(),
-        null
+        null,
+        product.getLikeCount()
     );
   }
 
@@ -23,7 +25,8 @@ public static ProductInfo from(Product product, String brandName) {
         product.getId(),
         product.getName(),
         product.getPrice(),
-        brandName
+        brandName,
+        product.getLikeCount()
     );
   }
 }

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

@@ -0,0 +1,55 @@
+package com.loopers.domain.coupon;
+
+import com.loopers.domain.BaseEntity;
+import com.loopers.support.error.CoreException;
+import com.loopers.support.error.ErrorType;
+import jakarta.persistence.Column;
+import jakarta.persistence.Entity;
+import jakarta.persistence.EnumType;
+import jakarta.persistence.Enumerated;
+import jakarta.persistence.Table;
+import lombok.AccessLevel;
+import lombok.NoArgsConstructor;
+
+@Entity
+@Table(name = "coupon")
+@NoArgsConstructor(access = AccessLevel.PROTECTED)
+public class Coupon extends BaseEntity {
+
+  @Column(name = "ref_user_id", nullable = false)
+  private long userId;
+
+  @Enumerated(EnumType.STRING)
+  @Column(nullable = false)
+  private CouponType type;
+
+  private long discountValue;
+
+  private boolean used;
+
+  public Coupon(long userId, CouponType type, long discountValue) {
+    if (type == CouponType.PERCENTAGE && (discountValue < 0 || discountValue > 100)) {
+      throw new CoreException(ErrorType.BAD_REQUEST, "할인율은 0~100% 사이여야 합니다.");
+    }
+    this.userId = userId;
+    this.type = type;
+    this.discountValue = discountValue;
+    this.used = false;
+  }
+
+  public boolean isUsed() {
+    return used;
+  }
+
+  public long calculateDiscountAmount(long totalOrderAmount) {
+    return this.type.calculate(totalOrderAmount, this.discountValue);
+  }
+
+  public void use() {
+    if (this.used) {
+      throw new CoreException(ErrorType.BAD_REQUEST, "이미 사용된 쿠폰입니다.");
+    }
+    this.used = true;
+  }
+
+}

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

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

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

@@ -0,0 +1,19 @@
+package com.loopers.domain.coupon;
+
+import com.loopers.support.error.CoreException;
+import com.loopers.support.error.ErrorType;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Component;
+
+@RequiredArgsConstructor
+@Component
+public class CouponService {
+
+  private final CouponRepository couponRepository;
+
+
+  public Coupon getCoupon(Long id) {
+    return couponRepository.findById(id)
+        .orElseThrow(() -> new CoreException(ErrorType.NOT_FOUND, "쿠폰을 찾을 수 없습니다."));
+  }
+}

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

@@ -0,0 +1,18 @@
+package com.loopers.domain.coupon;
+
+public enum CouponType {
+  FIXED_AMOUNT {
+    @Override
+    public long calculate(long totalAmount, long discountValue) {
+      return Math.min(totalAmount, discountValue);
+    }
+  },
+  PERCENTAGE {
+    @Override
+    public long calculate(long totalAmount, long discountValue) {
+      return (long) (totalAmount * (discountValue / 100.0));
+    }
+  };
+
+  public abstract long calculate(long totalAmount, long discountValue);
+}

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

@@ -1,24 +1,26 @@
 package com.loopers.domain.like;
 
+import java.util.Optional;
 import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
 
 @Component
 @RequiredArgsConstructor
 public class LikeService {
 
   private final LikeRepository likeRepository;
 
-  public Like like(long userId, long productId) {
-    return likeRepository.findByUserIdAndProductId(userId, productId)
-        .orElseGet(() -> likeRepository.save(new Like(userId, productId)));
+  public Like save(long userId, long productId) {
+    return likeRepository.save(new Like(userId, productId));
   }
 
-  public void unLike(Long userId, Long productId) {
-    likeRepository.deleteByUserIdAndProductId(userId, productId);
+  public Optional<Like> findLike(long userId, long productId) {
+    return likeRepository.findByUserIdAndProductId(userId, productId);
   }
 
-  public long countLikesByProductId(Long productId) {
-    return likeRepository.countByProductId(productId);
+  @Transactional
+  public void unLike(Long userId, Long productId) {
+    likeRepository.deleteByUserIdAndProductId(userId, productId);
   }
 }

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

@@ -1,11 +1,14 @@
 package com.loopers.domain.order;
 
 import com.loopers.domain.BaseEntity;
+import com.loopers.domain.money.Money;
 import com.loopers.domain.product.Product;
 import com.loopers.support.error.CoreException;
 import com.loopers.support.error.ErrorType;
+import jakarta.persistence.AttributeOverride;
 import jakarta.persistence.CascadeType;
 import jakarta.persistence.Column;
+import jakarta.persistence.Embedded;
 import jakarta.persistence.Entity;
 import jakarta.persistence.JoinColumn;
 import jakarta.persistence.OneToMany;
@@ -19,11 +22,15 @@
 @NoArgsConstructor(access = AccessLevel.PROTECTED)
 public class Order extends BaseEntity {
 
-  @Column(nullable = false)
+  @Column(name = "ref_user_id", nullable = false)
   private Long userId;
 
+  @Embedded
+  @AttributeOverride(name = "value", column = @Column(name = "total_amount"))
+  private Money totalAmount;
+
   @OneToMany(cascade = CascadeType.ALL, orphanRemoval = true)
-  @JoinColumn(name = "order_id")
+  @JoinColumn(name = "order_id", nullable = false)
   private List<OrderItem> orderItems = new java.util.ArrayList<>();
 
   public Order(Long userId, List<OrderItem> orderItems) {
@@ -36,6 +43,7 @@ public Order(Long userId, List<OrderItem> orderItems) {
     }
     this.userId = userId;
     this.orderItems = orderItems;
+    this.totalAmount = new Money(calculateTotalAmount());
   }
 
   public Long getUserId() {
@@ -64,4 +72,8 @@ public long calculateTotalAmount() {
         .mapToLong(OrderItem::calculateAmount)
         .sum();
   }
+
+  public Money getTotalAmount() {
+    return totalAmount;
+  }
 }