InventoryCommandRepository 추가

build.gradle

@@ -26,6 +26,7 @@ dependencies {
 	implementation 'org.springframework.boot:spring-boot-starter-validation'
 	implementation 'mysql:mysql-connector-java:8.0.22'
 	implementation 'org.springframework.boot:spring-boot-starter-data-redis'
+	implementation 'org.redisson:redisson-spring-boot-starter:3.21.3'
 	implementation 'org.flywaydb:flyway-core'
 	implementation 'org.flywaydb:flyway-mysql'
 	developmentOnly 'org.springframework.boot:spring-boot-devtools'

src/main/java/com/hcommerce/heecommerce/common/dao/RedisStringsRepository.java

@@ -43,4 +43,8 @@ public long decreaseByAmount(String key, long amount) {
     public long increaseByAmount(String key, long amount) {
         return redisTemplate.opsForValue().increment(key, amount); // 증가시킨 후의 결과값이 return된다.
     }
+
+    public void delete(String key) {
+        redisTemplate.delete(key);
+    }
 }

src/main/java/com/hcommerce/heecommerce/inventory/InventoryCommandRepository.java

@@ -0,0 +1,95 @@
+package com.hcommerce.heecommerce.inventory;
+
+import com.hcommerce.heecommerce.common.dao.RedisStringsRepository;
+import java.util.concurrent.TimeUnit;
+import org.redisson.api.RLock;
+import org.redisson.api.RedissonClient;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Repository;
+
+@Repository
+public class InventoryCommandRepository {
+
+    private final RedisStringsRepository redisStringsRepository;
+
+    private final RedissonClient redissonClient;
+
+    private int waitTimeForAcquiringLock  = 1;
+
+    private int leaseTimeForLock  = 1;
+
+    @Autowired
+    public InventoryCommandRepository(
+        RedisStringsRepository redisStringsRepository,
+        RedissonClient redissonClient
+    ) {
+        this.redisStringsRepository = redisStringsRepository;
+        this.redissonClient = redissonClient;
+    }
+
+    public void set(String key, int amount) {
+        redisStringsRepository.set(key, String.valueOf(amount));
+    }
+
+    public void delete(String key) {
+        redisStringsRepository.delete(key);
+    }
+
+    // TODO : 삭제 예정 -> Lock 걸었을 때와 안 걸었을 때 차이를 살펴보기 위해 만든 임시 메서드
+    public void decreaseByAmountWithoutLock(String key, int amount) {
+        redisStringsRepository.decreaseByAmount(key, Long.valueOf(amount));
+    }
+
+    /**
+     *
+     * 재고 데이터의 정합성을 Watch/Multi/Exec를 사용해서 보장할 수 있으나, 이 경우에는 retry 로직이 필요할 수 있다.
+     * 그래서, lock은 setnx 또는 redisson 에서 제공해 주는 lock을 많이 사용한다.
+     * 참고 : https://www.inflearn.com/questions/630130/spring-data-redis-%EA%B4%80%EB%A0%A8-%EC%A7%88%EB%AC%B8
+     */
+    public void decreaseByAmount(String key, int amount) {
+
+        RLock rlock = redissonClient.getLock(key+"lock");
+
+        try {
+
+            boolean available = rlock.tryLock(waitTimeForAcquiringLock, leaseTimeForLock, TimeUnit.SECONDS);
+
+            if (!available) {
+                System.out.println("lock 획득 실패 "); // TODO : logger 의논 후 수정하기
+                return;
+            }
+
+            redisStringsRepository.decreaseByAmount(key, Long.valueOf(amount));
+
+        } catch (InterruptedException e) {
+            throw new RuntimeException(e); // TODO : 예외 처리 어떻게 할까?
+        } finally {
+            if (rlock != null && rlock.isLocked()) {
+                rlock.unlock();
+            }
+        }
+    }
+
+    public void increaseByAmount(String key, int amount) {
+
+        RLock rlock = redissonClient.getLock(key);
+
+        try {
+            boolean available = rlock.tryLock(waitTimeForAcquiringLock, leaseTimeForLock, TimeUnit.SECONDS);
+
+            if (!available) {
+                System.out.println("lock 획득 실패"); // TODO : logger 의논 후 수정하기
+                return;
+            }
+
+            redisStringsRepository.increaseByAmount(key, Long.valueOf(amount));
+
+        } catch (InterruptedException e) {
+            throw new RuntimeException(e);
+        } finally {
+            if (rlock != null && rlock.isLocked()) {
+                rlock.unlock();
+            }
+        }
+    }
+}

src/test/java/com/hcommerce/heecommerce/inventory/InventoryCommandRepositoryTest.java

@@ -0,0 +1,165 @@
+package com.hcommerce.heecommerce.inventory;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotEquals;
+
+import com.hcommerce.heecommerce.common.dao.RedisStringsRepository;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.data.redis.core.RedisTemplate;
+
+@DisplayName("InventoryCommandRepository")
+@SpringBootTest
+public class InventoryCommandRepositoryTest {
+
+    @Autowired
+    private InventoryCommandRepository inventoryCommandRepository;
+
+    @Autowired
+    private RedisStringsRepository redisStringsRepository;
+
+    @Autowired
+    private RedisTemplate<String, String> redisTemplate;
+
+    String key = "testKey";
+
+    int initialAmount = 100;
+
+    @BeforeEach
+    public void setUp() {
+        redisStringsRepository.set(key, String.valueOf(initialAmount));
+    }
+
+    @AfterEach
+    void teardown() {
+        redisStringsRepository.delete(key);
+    }
+
+    @Nested
+    @DisplayName("decreaseByAmountWithoutLock")
+    class Describe_decreaseByAmountWithoutLock {
+
+        @Nested
+        @DisplayName("with 1 thread")
+        class Context_With_Single_Thread {
+
+            @Test
+            @DisplayName("decreases inventory by amount")
+            void It_Decreases_Inventory_By_Amount() throws InterruptedException {
+                int decreaseAmount = 1;
+
+                inventoryCommandRepository.decreaseByAmountWithoutLock(key, decreaseAmount);
+
+                String value = redisStringsRepository.get(key);
+
+                int expectedAmount = initialAmount - decreaseAmount;
+
+                assertEquals(expectedAmount, Integer.valueOf(value));
+            }
+        }
+
+        @Nested
+        @DisplayName("with multi thread")
+        class Context_With_Multi_Thread {
+
+            @Test
+            @DisplayName("does not decrease inventory by amount")
+            void It_Does_Not_Decrease_Inventory_By_Amount() throws InterruptedException {
+                int threadCount = 100;
+
+                int decreaseAmount = 1;
+
+                ExecutorService executorService = Executors.newFixedThreadPool(32);
+
+                CountDownLatch latch = new CountDownLatch(threadCount);
+
+                for (int i = 0; i < threadCount; i++) {
+                    executorService.submit(() -> {
+                        try {
+                            // Perform the test
+                            inventoryCommandRepository.decreaseByAmountWithoutLock(key, decreaseAmount);
+                        } catch (Exception e) {
+                            System.out.println(e.getMessage());
+                        } finally {
+                            latch.countDown();
+                        }
+                    });
+                }
+
+                latch.await();
+
+                String value = redisStringsRepository.get(key);
+
+                assertNotEquals(0, Integer.valueOf(value));
+            }
+        }
+    }
+
+    @Nested
+    @DisplayName("decreaseByAmount")
+    class Describe_decreaseByAmount {
+
+        @Nested
+        @DisplayName("with 1 thread")
+        class Context_With_Single_Thread {
+
+            @Test
+            @DisplayName("decreases inventory by amount")
+            void It_Decreases_Inventory_By_Amount() throws InterruptedException {
+                int decreaseAmount = 1;
+
+                inventoryCommandRepository.decreaseByAmount(key, decreaseAmount);
+
+                String value = redisStringsRepository.get(key);
+
+                int expectedAmount = initialAmount - decreaseAmount;
+
+                assertEquals(expectedAmount, Integer.valueOf(value));
+            }
+        }
+
+        @Nested
+        @DisplayName("with multi thread")
+        class Context_With_Multi_Thread {
+
+            @Test
+            @DisplayName("decrease inventory by amount")
+            void It_Does_Not_Decrease_Inventory_By_Amount() throws InterruptedException {
+                int threadCount = 100;
+
+                int decreaseAmount = 1;
+
+                ExecutorService executorService = Executors.newFixedThreadPool(32);
+
+                CountDownLatch latch = new CountDownLatch(threadCount);
+
+                for (int i = 0; i < threadCount; i++) {
+                    executorService.submit(() -> {
+                        try {
+                            // Perform the test
+                            inventoryCommandRepository.decreaseByAmount(key, decreaseAmount);
+                        } catch (Exception e) {
+                            System.out.println(e.getMessage());
+                        } finally {
+                            latch.countDown(); // Latch의 숫자가 1개씩 감소
+                        }
+                    });
+                }
+
+                latch.await(); // Latch의 숫자가 0이 될 때까지 기다리는 코드
+
+                String value = redisStringsRepository.get(key);
+
+                assertEquals(0, Integer.valueOf(value));
+            }
+        }
+    }
+}