[🌱 JPA 방탈출 예약 대기] 도우너(한수진) 미션 제출합니다.

README.md

@@ -1,14 +1,14 @@
-# 방탈출 예약 대기 미션
+# JPA 방탈출 예약 대기
 
 ## 기능 명세
 
-- [x] `reservation_waiting` 반정규화 — `reservation` 직접 참조 제거, `date` / `theme_id` / `time_id` 직접 보유
-- [x] 예약 취소 시 첫 번째 대기자를 자동으로 예약으로 승격
-    - [x] 취소 대상 예약의 대기 존재 여부 확인
-    - [x] 첫 번째 대기자를 신규 예약으로 등록
-    - [x] 승격된 대기 데이터 삭제
-    - [x] 대기 순번은 `requested_at` 오름차순으로 결정되며 승격 후 자동 재정렬
-- [x] 취소·승격 과정 중 실패 시 트랜잭션 롤백으로 데이터 일관성 보장
+1단계
+- [X] 매핑 변환
+  - [X] Theme 매핑 변환
+  - [X] ReservationTime 매핑 변환
+- [ ] 연관관계 매핑
+  - [X] Reservation 매핑
+  - [ ] ReservationWaiting 매핑
 
 ## API 명세
 

build.gradle

@@ -19,7 +19,7 @@ repositories {
 dependencies {
     implementation 'org.springframework.boot:spring-boot-starter'
     implementation 'org.springframework.boot:spring-boot-starter-web'
-    implementation 'org.springframework.boot:spring-boot-starter-jdbc'
+    implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
     implementation 'org.springframework.boot:spring-boot-starter-thymeleaf'
     implementation 'org.springframework.boot:spring-boot-starter-validation'
 

src/main/java/roomescape/application/ReservationApplicationService.java

@@ -9,24 +9,34 @@
 import roomescape.exception.ErrorCode;
 import roomescape.reservation.Reservation;
 import roomescape.reservation.service.ReservationService;
+import roomescape.reservationtime.ReservationTime;
+import roomescape.reservationtime.service.ReservationTimeService;
 import roomescape.reservationwaiting.ReservationWaiting;
 import roomescape.reservationwaiting.service.ReservationWaitingService;
+import roomescape.theme.Theme;
+import roomescape.theme.service.ThemeService;
 
 @Service
 public class ReservationApplicationService {
     private static final Logger log = LoggerFactory.getLogger(ReservationApplicationService.class);
     private final ReservationService reservationService;
     private final ReservationWaitingService reservationWaitingService;
     private final WaitingPromotionService waitingPromotionService;
+    private final ThemeService themeService;
+    private final ReservationTimeService reservationTimeService;
 
     public ReservationApplicationService(
             final ReservationService reservationService,
             final ReservationWaitingService reservationWaitingService,
-            final WaitingPromotionService waitingPromotionService
+            final WaitingPromotionService waitingPromotionService,
+            final ThemeService themeService,
+            final ReservationTimeService reservationTimeService
     ) {
         this.reservationService = reservationService;
         this. reservationWaitingService = reservationWaitingService;
         this.waitingPromotionService = waitingPromotionService;
+        this.themeService = themeService;
+        this.reservationTimeService = reservationTimeService;
     }
 
     @Transactional
@@ -35,7 +45,10 @@ public ReservationWaiting saveWaiting(String name, LocalDate date, Long themeId,
         Reservation reservation = reservationService.findByDateAndThemeIdAndTimeId(date, themeId, timeId);
         validateReservationOwner(name, reservation);
 
-        return reservationWaitingService.save(name, date, themeId, timeId);
+        Theme theme = themeService.getById(themeId);
+        ReservationTime time = reservationTimeService.getById(timeId);
+
+        return reservationWaitingService.save(name, date, theme, time);
     }
 
     public void cancelReservation(Long id, String name) {

src/main/java/roomescape/history/service/MyHistoryService.java

@@ -2,6 +2,7 @@
 
 import java.util.List;
 import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
 import roomescape.history.MyHistory;
 import roomescape.history.repository.MyHistoryRepository;
 
@@ -14,6 +15,7 @@ public MyHistoryService(final MyHistoryRepository myHistoryRepository) {
         this.myHistoryRepository = myHistoryRepository;
     }
 
+    @Transactional
     public List<MyHistory> getAllByName(final String name) {
         return myHistoryRepository.findByUserName(name);
     }

src/main/java/roomescape/reservation/Reservation.java

@@ -1,17 +1,54 @@
 package roomescape.reservation;
 
+import jakarta.persistence.Column;
+import jakarta.persistence.Entity;
+import jakarta.persistence.FetchType;
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.GenerationType;
+import jakarta.persistence.Id;
+import jakarta.persistence.JoinColumn;
+import jakarta.persistence.ManyToOne;
+import jakarta.persistence.Table;
+import jakarta.persistence.UniqueConstraint;
 import java.time.LocalDate;
 import java.time.LocalDateTime;
 import java.util.Objects;
 import roomescape.reservationtime.ReservationTime;
 import roomescape.theme.Theme;
 
+@Entity
+@Table(name = "reservation",
+    uniqueConstraints = {
+            @UniqueConstraint(
+                    columnNames = {
+                            "date",
+                            "theme_id",
+                            "time_id"
+                    }
+            ),
+    }
+)
 public class Reservation {
-    private final Long id;
-    private final String name;
-    private final LocalDate date;
-    private final Theme theme;
-    private final ReservationTime time;
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @Column(nullable = false)
+    private String name;
+
+    @Column(nullable = false)
+    private LocalDate date;
+
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "theme_id")
+    private Theme theme;
+
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "time_id")
+    private ReservationTime time;
+
+    protected Reservation() {}
 
     private Reservation(final Long id, final String name, final LocalDate date, final Theme theme, final ReservationTime time) {
         validate(name, date, theme, time);

src/main/java/roomescape/reservation/repository/JpaReservationRepository.java

@@ -0,0 +1,28 @@
+package roomescape.reservation.repository;
+
+import java.time.LocalDate;
+import java.util.List;
+import java.util.Optional;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.query.Param;
+import roomescape.reservation.Reservation;
+
+public interface JpaReservationRepository extends JpaRepository<Reservation, Long> {
+    Optional<Reservation> findByIdAndName(long id, String name);
+
+    Optional<Reservation> findByDateAndThemeIdAndTimeId(LocalDate date, long themeId, long timeId);
+
+    boolean existsByTimeId(long timeId);
+
+    boolean existsByThemeId(long themeId);
+
+    // 예약이 생성 시 중복 예약인지 확인
+    boolean existsByDateAndThemeIdAndTimeId(LocalDate date, long themeId, long timeId);
+
+    // 예약 수정 시 중복 예약이 되는지 확인 (내 예약 충돌 제거)
+    boolean existsByDateAndThemeIdAndTimeIdAndIdNot(LocalDate date, long themeId, long timeId, long reservationId);
+
+    @Query("SELECT r.time.id FROM Reservation r WHERE r.date = :date AND r.theme.id = :themeId")
+    List<Long> findReservedTimeIdsByDateAndThemeId(@Param("date") LocalDate date, @Param("themeId") long themeId);
+}

src/main/java/roomescape/reservation/service/ReservationService.java

@@ -9,35 +9,37 @@
 import roomescape.exception.ResourceNotFoundException;
 import roomescape.reservation.Reservation;
 import roomescape.reservation.ReservationValidator;
-import roomescape.reservation.repository.ReservationRepository;
+import roomescape.reservation.repository.JpaReservationRepository;
 import roomescape.reservationtime.ReservationTime;
 import roomescape.reservationtime.service.ReservationTimeService;
 import roomescape.theme.Theme;
 import roomescape.theme.service.ThemeService;
 
 @Service
+@Transactional(readOnly = true)
 public class ReservationService {
-    private final ReservationRepository reservationRepository;
+    private final JpaReservationRepository jpaReservationRepository;
     private final ReservationTimeService reservationTimeService;
     private final ThemeService themeService;
     private final ReservationValidator reservationValidator;
 
     public ReservationService(
-            final ReservationRepository reservationRepository,
+            final JpaReservationRepository jpaReservationRepository,
             final ReservationTimeService reservationTimeService,
             final ThemeService themeService,
             final ReservationValidator reservationValidator
     ) {
-        this.reservationRepository = reservationRepository;
+        this.jpaReservationRepository = jpaReservationRepository;
         this.reservationTimeService = reservationTimeService;
         this.themeService = themeService;
         this.reservationValidator = reservationValidator;
     }
 
     public List<Reservation> getAll() {
-        return reservationRepository.findAll();
+        return jpaReservationRepository.findAll();
     }
 
+    @Transactional
     public Reservation save(final String name, final LocalDate date, final Long themeId, final Long timeId) {
         reservationValidator.validateCreateReferenceIds(themeId, timeId);
 
@@ -46,56 +48,60 @@ public Reservation save(final String name, final LocalDate date, final Long them
         Reservation nonIdReservation = Reservation.createNew(name, date, theme, reservationTime);
         reservationValidator.validateReservable(nonIdReservation);
 
-        if(reservationRepository.existsByDateAndThemeIdAndTimeId(date, themeId, timeId)){
+        if(jpaReservationRepository.existsByDateAndThemeIdAndTimeId(date, themeId, timeId)){
             throw new ConflictException(ErrorCode.RESERVATION_DUPLICATED, "동일한 시기에 예약을 할 수 없습니다.");
         }
 
-        return reservationRepository.save(nonIdReservation);
+        return jpaReservationRepository.save(nonIdReservation);
     }
 
+
+    @Transactional
     public void saveWith(String name, LocalDate date, Theme theme, ReservationTime reservationTime) {
         Reservation nonIdReservation = Reservation.createNew(name, date, theme, reservationTime);
 
-        reservationRepository.save(nonIdReservation);
+        jpaReservationRepository.save(nonIdReservation);
     }
 
     public Reservation findByDateAndThemeIdAndTimeId(final LocalDate date, final Long themeId, final Long timeId) {
-        return reservationRepository.findByDateAndThemeIdAndTimeId(date, themeId, timeId)
+        return jpaReservationRepository.findByDateAndThemeIdAndTimeId(date, themeId, timeId)
                 .orElseThrow(() -> new ResourceNotFoundException(
                         ErrorCode.RESERVATION_NOT_FOUND,
                         "해당 예약을 찾을 수 없습니다."
                 ));
     }
 
+    @Transactional
     public void deleteById(final long id) {
-        int affectedRowCount = reservationRepository.deleteById(id);
-
-        if(affectedRowCount <= 0) {
+        if (!jpaReservationRepository.existsById(id)){
             throw new ResourceNotFoundException(ErrorCode.RESERVATION_NOT_FOUND, "삭제된 예약 데이터가 없습니다.");
         }
+
+        jpaReservationRepository.deleteById(id);
     }
 
     @Transactional
     public Reservation deleteByIdAndName(final long id, final String name) {
         reservationValidator.validateLookupName(name);
 
-        Reservation reservation = reservationRepository.findByIdAndName(id, name)
+        Reservation reservation = jpaReservationRepository.findByIdAndName(id, name)
                 .orElseThrow(() -> new ResourceNotFoundException(
                         ErrorCode.MY_RESERVATION_NOT_FOUND,
                         "조회한 이름으로 찾은 예약이 없습니다."
                 ));
 
         reservationValidator.validateCancelable(reservation);
 
-        int affectedRowCount = reservationRepository.deleteById(reservation.getId());
-
-        if(affectedRowCount <= 0) {
+        if (!jpaReservationRepository.existsById(id)) {
             throw new ResourceNotFoundException(ErrorCode.RESERVATION_NOT_FOUND, "해당 예약 데이터가 존재하지 않습니다.");
         }
 
+        jpaReservationRepository.deleteById(reservation.getId());
+
         return reservation;
     }
 
+    @Transactional
     public Reservation updateByIdAndName(
             final long id,
             final String name,
@@ -105,7 +111,7 @@ public Reservation updateByIdAndName(
         reservationValidator.validateLookupName(name);
         reservationValidator.validateUpdateReferenceIds(timeId);
 
-        Reservation reservation = reservationRepository.findByIdAndName(id, name)
+        Reservation reservation = jpaReservationRepository.findByIdAndName(id, name)
                 .orElseThrow(() -> new ResourceNotFoundException(
                         ErrorCode.MY_RESERVATION_NOT_FOUND,
                         "조회한 이름으로 찾은 예약이 없습니다."
@@ -117,7 +123,7 @@ public Reservation updateByIdAndName(
         Reservation updatedReservation = reservation.withDateAndTime(date, reservationTime);
         reservationValidator.validateReservable(updatedReservation);
 
-        if (reservationRepository.existsByDateAndThemeIdAndTimeIdExcludingId(
+        if (jpaReservationRepository.existsByDateAndThemeIdAndTimeIdAndIdNot(
                 date,
                 reservation.getTheme().getId(),
                 timeId,
@@ -126,6 +132,6 @@ public Reservation updateByIdAndName(
             throw new ConflictException(ErrorCode.RESERVATION_DUPLICATED, "동일한 시기에 예약을 할 수 없습니다.");
         }
 
-        return reservationRepository.update(updatedReservation);
+        return jpaReservationRepository.save(updatedReservation);
     }
 }

src/main/java/roomescape/reservationtime/ReservationTime.java

@@ -1,11 +1,22 @@
 package roomescape.reservationtime;
 
+import jakarta.persistence.Entity;
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.GenerationType;
+import jakarta.persistence.Id;
 import java.time.LocalTime;
 import java.util.Objects;
 
+@Entity
 public class ReservationTime {
-    private final Long id;
-    private final LocalTime startAt;
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    private LocalTime startAt;
+
+    protected ReservationTime() {}
 
     private ReservationTime(final Long id, final LocalTime startAt) {
         validateStartAt(startAt);

src/main/java/roomescape/reservationtime/repository/JpaReservationTimeRepository.java

@@ -0,0 +1,10 @@
+package roomescape.reservationtime.repository;
+
+import java.time.LocalTime;
+import org.springframework.data.jpa.repository.JpaRepository;
+import roomescape.reservationtime.ReservationTime;
+
+public interface JpaReservationTimeRepository extends JpaRepository<ReservationTime, Long> {
+
+    boolean existsByStartAt(LocalTime startAt);
+}