3-4주차 과제

[hongs429]

[예약 시스템 구현 및 동시성 제어]

---

작업 내용

• 예약과 관련된 application, infra 모듈 작업 (presentation 미완성)

• 동시성 해결을 위한 이중 방어 적용

  • 1차: ReservationCommandAdapter.reserve (MySQL) → Unique 제약 조건으로 동시성 제어

        @Entity
      @Builder
      @Table(name = "reservation_seat", uniqueConstraints = {
              @UniqueConstraint(
                      name = "UK_screening_seat",
                      columnNames = {"screening_id", "seat_id"}
              )
      })
      @Getter
      @AllArgsConstructor
      @NoArgsConstructor(access = AccessLevel.PROTECTED)
      public class ReservationSeatJpaEntity extends BaseJpaEntity {
      
          @Id
          @GeneratedValue(generator = "uuid")
          @UuidGenerator
          @Column(name = "reservation_seat_id", columnDefinition = "BINARY(16)")
          private UUID id;
      
          @ManyToOne(fetch = FetchType.LAZY)
          @JoinColumn(name = "reservation_id", foreignKey = @ForeignKey(ConstraintMode.NO_CONSTRAINT))
          private ReservationJpaEntity reservation;
      
          @ManyToOne
          @JoinColumn(name = "screening_id", foreignKey = @ForeignKey(ConstraintMode.NO_CONSTRAINT))
          private ScreeningJpaEntity screening;
      
          @ManyToOne
          @JoinColumn(name = "seat_id", foreignKey = @ForeignKey(ConstraintMode.NO_CONSTRAINT))
          private SeatJpaEntity seat;
      }

  • 2차: ReservationLockPort (Redisson) → Application 레벨에서 분산 락 적용

      @Slf4j
    @Component
    @RequiredArgsConstructor
    public class ReservationLockAdapter implements ReservationLockPort {
    
        private final RedissonClient redissonClient;
    
        @Override
        public boolean tryLock(String lockKey, long waitTimeMils, long releaseTimeMils) {
            RLock lock = redissonClient.getLock(lockKey);
            try {
                return lock.tryLock(waitTimeMils, releaseTimeMils, TimeUnit.MILLISECONDS);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                return false;
            }
        }
    
        @Override
        public boolean tryScreeningSeatLock(List<String> lockKeys, long waitTimeMils, long releaseTimeMils) {
            RLock[] locks = lockKeys.stream()
                    .map(redissonClient::getLock)
                    .toArray(RLock[]::new);
    
            RLock multiLock = redissonClient.getMultiLock(locks);
    
            try {
                log.info("Trying to acquire multi-lock for keys: {}", lockKeys);
                boolean acquired = multiLock.tryLock(waitTimeMils, releaseTimeMils, TimeUnit.MILLISECONDS);
                log.info("Multi-lock acquired: {}", acquired);
                return acquired;
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                return false;
            }
        }
    
        @Override
        public void releaseLock(String lockKey) {
            RLock lock = redissonClient.getLock(lockKey);
            if (lock.isHeldByCurrentThread()) {
                log.info("Release lock ...{}", lockKey);
                lock.unlock();
            }
        }
    
        @Override
        public void releaseMultiLock(List<String> lockKeys) {
            lockKeys.forEach(lockKey -> {
                RLock lock = redissonClient.getLock(lockKey);
                if (lock.isHeldByCurrentThread()) {
                    log.info("Release lock ...{}", lockKey);
                    lock.unlock();
                }
            });
        }
    }

• 테스트 전략

  • application: 단위 테스트 (입력 모델 검증 + 비즈니스 로직 검증)
  • infra: ReservationCommandAdapter.reserve 단위 테스트
  • 통합 테스트: application -> infra 경로를 거치는 통합 테스트 진행
  • TestContainer 활용: 동일한 환경에서 테스트 수행

      @SpringBootApplication(scanBasePackages = {"project.redis.infrastructure", "project.redis.application"})
      public class IntegrationTestConfiguration {
      }
  
  
  
  
  
      public abstract class TestContainerSupport {
      
      @Container
      public static final MySQLContainer<?> mysqlContainer
              = new MySQLContainer<>("mysql:9.1.0")
              .withDatabaseName("db")
              .withUsername("user")
              .withPassword("1234")
              .withCommand(
                      "--character-set-server=utf8mb4",
                      "--collation-server=utf8mb4_unicode_ci"
              );
      
      @Container
      public static final GenericContainer<?> redisContainer
              = new GenericContainer<>("redis")
              .withExposedPorts(6379);
      
      static {
          mysqlContainer.start();
          redisContainer.start();
      }
      
      @DynamicPropertySource
      static void setDatasourceProperties(DynamicPropertyRegistry registry) {
          System.out.println("mysqlContainer = " + mysqlContainer.getJdbcUrl());
          registry.add("spring.datasource.url", ()-> mysqlContainer.getJdbcUrl() + "?useSSL=false&allowPublicKeyRetrieval=true");
          registry.add("spring.datasource.username", mysqlContainer::getUsername);
          registry.add("spring.datasource.password", mysqlContainer::getPassword);
          registry.add("spring.datasource.driver-class-name", mysqlContainer::getDriverClassName);
      
          registry.add("redis.host", redisContainer::getHost);
          registry.add("redis.port", () -> redisContainer.getMappedPort(6379).toString());
      }
      }
  
  
  
  
  
  
      @Slf4j
      @SpringBootTest
      @ContextConfiguration(classes = IntegrationTestConfiguration.class)
      @TestConstructor(autowireMode = TestConstructor.AutowireMode.ALL)
      @RequiredArgsConstructor
      public class ReservationCommandServiceIntegrationTest extends TestContainerSupport {
      
      private final ReservationCommandService reservationCommandService;
      
      private final ReservationJpaRepository reservationJpaRepository;
      private final ReservationSeatJpaRepository reservationSeatJpaRepository;
      private final ScreeningJpaRepository screeningJpaRepository;
      private final SeatJpaRepository seatJpaRepository;
      
      @AfterEach
      void tearDown() {
          reservationSeatJpaRepository.deleteAll();
          reservationJpaRepository.deleteAll();
      }
      
      @DisplayName("상영 예약 동시성 테스트")
      @Test
      void testReservationConcurrency() throws InterruptedException {}
  

---

발생했던 문제와 해결 과정

🚨 문제 1: 통합 테스트를 어떤 모듈에서 작성해야 하는지 고민

• ⚠️ 고민: application은 infra를 모르므로, infra에서 작성해야 하는지 모호함
• ✅ 해결:
  • infra는 application을 알고 있고 DB 관련 내용도 포함하므로, 통합 테스트는 infra에서 작성하는 것으로 결정
  • infra에서는 application -> infra가 자연스럽게 연결될 수 있음

🚨 문제 2: 락을 application과 infra 중 어디서 적용할지 고민

• ⚠️ 고민: DB 트랜잭션(persistence)에서 락을 걸어야 할까? application 레벨에서 비즈니스 로직을 보호해야 할까?
• ✅ 해결:
  • ReservationLockPort를 application과 infra에서 분리
  • application에서 비즈니스 로직 전에 락을 먼저 시도, 이후 infra에서 DB 트랜잭션 처리

🚨 문제 3: Redisson의 waitTime이 길 경우, 이미 예약된 좌석이 있어도 계속 예약 시도

• ⚠️ 문제:
  • 락 대기 시간(waitTime)이 길면, 이미 예약된 좌석에 대해서도 중복 예약 시도가 발생
  • 결국 RDB 제약조건이 중복을 막지만, 불필요한 DB I/O가 발생
• ✅ 해결:
  • 락을 획득한 요청만 실행 → waitTime을 짧게 설정
  • DB에 접근하는 동시 요청을 줄여, 불필요한 IO 최소화

---

이번 주차에서 고민되었던 지점이나, 어려웠던 점

• 멀티 모듈 환경에서 통합 테스트를 어디서 작성해야 하는지 고민
  • 결론: infra에서 application -> infra 흐름을 테스트하는 것이 적절
• 1회 예약 시 여러 좌석을 예약하는 시스템에서, 비즈니스 로직의 위치 고민
  • 도메인 로직을 application에 둘지 infra에 둘지 판단하는 것이 어려웠음
• 트랜잭션의 범위 고민
  • 현재: 예약 및 좌석 등록을 하나의 트랜잭션으로 처리 → 큰 문제 없음
  • 하지만 경우에 따라 application까지 트랜잭션 전파가 필요할 가능성 존재

---

리뷰 포인트

• infra에서 통합 테스트를 작성한 것이 적절한 판단인지?
• application에서는 트랜잭션을 전파하지 않도록 구현했는데, 이는 올바른 설계인가?
  • 현재: 예약 & 예약-좌석 트랜잭션을 묶어도 문제 없음
  • 미래: 특정 상황에서는 application까지 트랜잭션을 잡아야 할 가능성 존재

---

기타 질문

• Redisson의 waitTime이 필요한 이유가 명확하지 않음
  • 현재 가정: "락을 해제할 때까지 동일한 요청은 반드시 차단되어야 한다"
  • **따라서 waitTime을 짧게 설정하여 동시 요청을 제한