[Feat]: Redis 분산락을 통한 입찰 동시성 문제 해결

RedissonConfig: Redisson 설정
DistributedLock: 분산락 어노테이션
DistributedLockAop: 분산락 AOP
AopForTransaction: 트랜잭션 분리용 AOP
BidService: 분산락 적용

BidConcurrencyTest: 100명 동시 입찰로 분산락 처리 검증
BidDistributedLockPerformanceTest: 동시성 및 성능 테스트

Author: Jiwoo-Seo

build.gradle.kts

@@ -30,6 +30,7 @@ dependencies {
     implementation("org.springframework.boot:spring-boot-starter-security")
     implementation("org.springframework.boot:spring-boot-starter-web")
     implementation("org.springframework.boot:spring-boot-starter-data-redis")
+    implementation("org.redisson:redisson-spring-boot-starter:3.18.0")
     implementation("org.springframework.boot:spring-boot-starter-websocket")
     implementation("org.springframework.boot:spring-boot-starter-webflux")
     implementation("org.springframework.boot:spring-boot-starter-data-elasticsearch")

src/main/java/com/backend/domain/bid/service/BidService.java

@@ -12,6 +12,7 @@
 import com.backend.domain.product.event.helper.ProductChangeTracker;
 import com.backend.domain.product.repository.jpa.ProductRepository;
 import com.backend.global.exception.ServiceException;
+import com.backend.global.lock.DistributedLock;
 import com.backend.global.response.RsData;
 import com.backend.global.websocket.service.WebSocketService;
 import lombok.RequiredArgsConstructor;
@@ -26,12 +27,10 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
-import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.stream.Collectors;
 
 @Service
-@Transactional
 @RequiredArgsConstructor
 public class BidService {
     private final BidRepository bidRepository;
@@ -40,20 +39,15 @@ public class BidService {
     private final WebSocketService webSocketService;
     private final BidNotificationService bidNotificationService;
     private final ApplicationEventPublisher eventPublisher;
-    private final Map<Long, Object> productLocks = new ConcurrentHashMap<>();
 
     // ======================================= create methods ======================================= //
+    @DistributedLock(key = "'product:' + #productId", waitTime = 10, leaseTime = 5)
     public RsData<BidResponseDto> createBid(Long productId, Long bidderId, BidRequestDto request) {
-        // 상품별 락 객체 가져오기 (없으면 생성)
-        Object lock = productLocks.computeIfAbsent(productId, k -> new Object());
-
-        // 동시성 제어: 같은 상품에 대한 입찰은 순차적으로 처리
-        synchronized (lock) {
-            return createBidInternal(productId, bidderId, request);
-        }
+        return createBidInternal(productId, bidderId, request);
     }
 
-    private RsData<BidResponseDto> createBidInternal(Long productId, Long bidderId, BidRequestDto request) {
+    @Transactional
+    public RsData<BidResponseDto> createBidInternal(Long productId, Long bidderId, BidRequestDto request) {
         // Product/Member 조회
         Product product = productRepository.findById(productId)
                 .orElseThrow(() -> ServiceException.notFound("존재하지 않는 상품입니다."));

src/main/java/com/backend/global/config/RedissonConfig.java

@@ -0,0 +1,36 @@
+package com.backend.global.config;
+
+import org.redisson.Redisson;
+import org.redisson.api.RedissonClient;
+import org.redisson.config.Config;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Profile;
+
+// 테스트 환경에서는 TestRedisConfiguration 사용
+@Configuration
+@Profile("!test & !bidtest")
+public class RedissonConfig {
+    
+    @Value("${spring.data.redis.host}")
+    private String redisHost;
+    
+    @Value("${spring.data.redis.port}")
+    private int redisPort;
+    
+    @Value("${spring.data.redis.password:}")
+    private String redisPassword;
+    
+    private static final String REDISSON_HOST_PREFIX = "redis://";
+    
+    @Bean
+    public RedissonClient redissonClient() {
+        Config config = new Config();
+        config.useSingleServer()
+                .setAddress(REDISSON_HOST_PREFIX + redisHost + ":" + redisPort)
+                .setPassword(redisPassword.isEmpty() ? null : redisPassword);
+        
+        return Redisson.create(config);
+    }
+}

src/main/java/com/backend/global/initdata/TestInitData.java

@@ -124,12 +124,22 @@ public void work2() {
         Product product9 = productService.saveProduct(member4, requestDto9);
         productImageService.createProductImage(product9, "/image9_1.jpg");
 
+        // 입찰 생성은 별도 트랜잭션으로 분리
+        self.createBids(product4.getId(), product9.getId(), member1.getId(), member2.getId());
+    }
+
+    @Transactional
+    public void createBids(Long product4Id, Long product9Id, Long member1Id, Long member2Id) {
         // 경매 진행
-        bidService.createBid(product4.getId(), member1.getId(), new BidRequestDto(1200000L));
-        bidService.createBid(product4.getId(), member2.getId(), new BidRequestDto(1300000L));
+        bidService.createBid(product4Id, member1Id, new BidRequestDto(1200000L));
+        bidService.createBid(product4Id, member2Id, new BidRequestDto(1300000L));
+
+        bidService.createBid(product9Id, member1Id, new BidRequestDto(900000L));
 
-        bidService.createBid(product9.getId(), member1.getId(), new BidRequestDto(900000L));
-        product9.setStatus("낙찰");
-        product9.setEndTime(LocalDateTime.now());
+        // 낙찰 처리
+        productService.findById(product9Id).ifPresent(product -> {
+            product.setStatus("낙찰");
+            product.setEndTime(LocalDateTime.now());
+        });
     }
 }

src/main/java/com/backend/global/lock/AopForTransaction.java

@@ -0,0 +1,18 @@
+package com.backend.global.lock;
+
+import org.aspectj.lang.ProceedingJoinPoint;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Propagation;
+import org.springframework.transaction.annotation.Transactional;
+
+/**
+ * AOP에서 트랜잭션 분리를 위한 클래스
+ */
+@Component
+public class AopForTransaction {
+    
+    @Transactional(propagation = Propagation.REQUIRES_NEW)
+    public Object proceed(final ProceedingJoinPoint joinPoint) throws Throwable {
+        return joinPoint.proceed();
+    }
+}

src/main/java/com/backend/global/lock/CustomSpringELParser.java

@@ -0,0 +1,25 @@
+package com.backend.global.lock;
+
+import org.springframework.expression.ExpressionParser;
+import org.springframework.expression.spel.standard.SpelExpressionParser;
+import org.springframework.expression.spel.support.StandardEvaluationContext;
+
+/**
+ * Spring Expression Language Parser
+ */
+public class CustomSpringELParser {
+    
+    private CustomSpringELParser() {
+    }
+    
+    public static Object getDynamicValue(String[] parameterNames, Object[] args, String key) {
+        ExpressionParser parser = new SpelExpressionParser();
+        StandardEvaluationContext context = new StandardEvaluationContext();
+        
+        for (int i = 0; i < parameterNames.length; i++) {
+            context.setVariable(parameterNames[i], args[i]);
+        }
+        
+        return parser.parseExpression(key).getValue(context, Object.class);
+    }
+}

src/main/java/com/backend/global/lock/DistributedLock.java

@@ -0,0 +1,27 @@
+package com.backend.global.lock;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * Redisson Distributed Lock annotation
+ */
+@Target(ElementType.METHOD)
+@Retention(RetentionPolicy.RUNTIME)
+public @interface DistributedLock {
+    
+    // 락의 이름
+    String key();
+    
+    // 락의 시간 단위
+    TimeUnit timeUnit() default TimeUnit.SECONDS;
+    
+    // 락을 기다리는 시간 (default - 5s) - 락 획득을 위해 waitTime 만큼 대기
+    long waitTime() default 5L;
+    
+    // 락 임대 시간 (default - 3s) - 락을 획득한 이후 leaseTime 이 지나면 락을 해제
+    long leaseTime() default 3L;
+}

src/main/java/com/backend/global/lock/DistributedLockAop.java

@@ -0,0 +1,72 @@
+package com.backend.global.lock;
+
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.aspectj.lang.ProceedingJoinPoint;
+import org.aspectj.lang.annotation.Around;
+import org.aspectj.lang.annotation.Aspect;
+import org.aspectj.lang.reflect.MethodSignature;
+import org.redisson.api.RLock;
+import org.redisson.api.RedissonClient;
+import org.springframework.stereotype.Component;
+
+import java.lang.reflect.Method;
+
+/**
+ * @DistributedLock 선언 시 수행되는 Aop class
+ */
+@Aspect
+@Component
+@RequiredArgsConstructor
+@Slf4j
+public class DistributedLockAop {
+    
+    private static final String REDISSON_LOCK_PREFIX = "LOCK:";
+    
+    private final RedissonClient redissonClient;
+    private final AopForTransaction aopForTransaction;
+    
+    @Around("@annotation(com.backend.global.lock.DistributedLock)")
+    public Object lock(final ProceedingJoinPoint joinPoint) throws Throwable {
+        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
+        Method method = signature.getMethod();
+        DistributedLock distributedLock = method.getAnnotation(DistributedLock.class);
+        
+        String key = REDISSON_LOCK_PREFIX + CustomSpringELParser.getDynamicValue(
+                signature.getParameterNames(),
+                joinPoint.getArgs(),
+                distributedLock.key()
+        );
+        
+        RLock rLock = redissonClient.getLock(key); // (1)
+        
+        try {
+            boolean available = rLock.tryLock(
+                    distributedLock.waitTime(),
+                    distributedLock.leaseTime(),
+                    distributedLock.timeUnit()
+            ); // (2)
+            
+            if (!available) {
+                log.warn("Redisson Lock 획득 실패 - method: {}, key: {}", method.getName(), key);
+                throw new RuntimeException("현재 다른 요청을 처리 중입니다. 잠시 후 다시 시도해주세요.");
+            }
+            
+            log.debug("Redisson Lock 획득 성공 - method: {}, key: {}", method.getName(), key);
+            return aopForTransaction.proceed(joinPoint); // (3)
+            
+        } catch (InterruptedException e) {
+            log.error("Redisson Lock 인터럽트 발생 - method: {}, key: {}", method.getName(), key);
+            throw new InterruptedException();
+        } finally {
+            try {
+                if (rLock.isHeldByCurrentThread()) {
+                    rLock.unlock(); // (4)
+                    log.debug("Redisson Lock 해제 - method: {}, key: {}", method.getName(), key);
+                }
+            } catch (IllegalMonitorStateException e) {
+                log.info("Redisson Lock Already UnLock - serviceName: {}, key: {}", method.getName(), key);
+            }
+        }
+    }
+}

src/main/java/com/backend/global/redis/RedisConfig.java

@@ -5,11 +5,13 @@
 import org.springframework.context.annotation.Configuration;
 import org.springframework.data.redis.connection.RedisPassword;
 import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
+import org.springframework.context.annotation.Profile;
 import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
 import org.springframework.data.redis.core.RedisTemplate;
 import org.springframework.data.redis.serializer.StringRedisSerializer;
 
 @Configuration
+@Profile("!test & !bidtest")
 public class RedisConfig {
 
     @Value("${spring.data.redis.host}")