Refactor : 북마크 C,R,D API 리팩토링 및 OPEN API DB에 저장 로직 구현

Author: hongjungwook1

tour/src/main/java/com/jocketdan/tour/controller/BookmarkController.java

@@ -2,7 +2,7 @@
 
 import com.jocketdan.tour.dto.BookmarkCountDTO;
 import com.jocketdan.tour.dto.PaginatedResponseDTO;
-import com.jocketdan.tour.dto.ResponsePlaceDTO;
+import com.jocketdan.tour.dto.ResponseBookmarkDTO;
 import com.jocketdan.tour.entity.BookmarkType;
 import com.jocketdan.tour.service.BookmarkService;
 import io.swagger.v3.oas.annotations.Operation;
@@ -32,38 +32,24 @@ public class BookmarkController {
     @Operation(
             summary = "북마크 추가",
             description = """
-                    특정 관광지를 북마크에 추가합니다.
-                    
-                    ### 파라미터 설명
-                    - **placeId**: OPEN API의 contentId (예: "126508", "264636")
-                    - **contentTypeId**: 콘텐츠 타입 ID
-                      - 12: 관광지
-                      - 14: 문화시설
-                      - 15: 축제 (자동으로 FESTIVAL 타입으로 분류)
-                      - 28: 레포츠
-                      - 32: 숙박
-                      - 38: 쇼핑
-                      - 39: 음식점
+                    특정 관광지를 북마크에 추가 시 DB에 OPEN API 정보들을 같이 저장합니다.
                     
                     ### 예시
                     ```
-                    POST /tour/bookmarks?placeId=126508&contentTypeId=12
+                    POST /tour/bookmarks?contentId=126508
                     ```
                     """,
             tags = {"북마크 관리"}
     )
     @PostMapping("/bookmarks")
     public ResponseEntity<Void> addBookmark(
             @Parameter(description = "OPEN API contentId", required = true)
-            @RequestParam String placeId,
-
-            @Parameter(description = "콘텐츠 타입 ID (12=관광지, 15=축제 등)", required = true)
-            @RequestParam Integer contentTypeId,
+            @RequestParam String contentId,
 
             Authentication authentication
     ) {
         String userEmail = authentication.getName();
-        bookmarkService.addBookmark(placeId, contentTypeId, userEmail);
+        bookmarkService.addBookmark(contentId, userEmail);
         return ResponseEntity.status(HttpStatus.CREATED).build();
     }
 
@@ -74,34 +60,33 @@ public ResponseEntity<Void> addBookmark(
                     여러 개를 동시에 삭제할 수 있습니다.
                     
                     ### 예시
-                    - 단일 삭제: `DELETE /tour/bookmarks?placeIds=126508`
-                    - 다중 삭제: `DELETE /tour/bookmarks?placeIds=126508,264636,125406`
+                    - 단일 삭제: `DELETE /tour/bookmarks?contentIds=126508`
+                    - 다중 삭제: `DELETE /tour/bookmarks?contentIds=126508,264636,125406`
                     """,
             tags = {"북마크 관리"}
     )
     @DeleteMapping("/bookmarks")
     public ResponseEntity<Void> removeBookmark(
             @Parameter(
-                    name = "placeIds",
-                    description = "삭제할 placeId (쉼표로 구분하여 여러 개 가능)",
+                    name = "contentIds",
+                    description = "삭제할 contentId (쉼표로 구분하여 여러 개 가능)",
                     required = true,
-                    example = "126508,264636",
                     schema = @Schema(type = "string")
             )
-            @RequestParam List<String> placeIds,
+            @RequestParam List<String> contentIds,
 
             Authentication authentication
     ) {
         String userEmail = authentication.getName();
-        bookmarkService.removeBookmark(placeIds, userEmail);
+        bookmarkService.removeBookmark(contentIds, userEmail);
         return ResponseEntity.noContent().build();
     }
 
     @Operation(
             summary = "내 북마크 목록 조회",
             description = """
                     현재 로그인한 사용자의 북마크 목록을 조회합니다.
-                    OPEN API에서 실시간으로 장소 정보를 가져와 함께 반환합니다.
+                    DB에 저장한 OPEN API에서 장소 정보를 가져와 함께 반환합니다.
                     
                     ### 타입별 조회
                     - **type=TOUR**: 일반 관광지 북마크만 조회
@@ -112,7 +97,7 @@ public ResponseEntity<Void> removeBookmark(
                     ### 정렬 (arrange)
                     - **T**: 제목 오름차순
                     - **C**: 최신 북마크 순 (기본값)
-                    - **R**: 평균 별점 높은 순
+                    `- **R**: 평균 별점 높은 순 (추후 구현 예정 / 아직 구현 안됐습니다)` 
                     
                     ### 예시
                     ```
@@ -122,11 +107,8 @@ public ResponseEntity<Void> removeBookmark(
             tags = {"북마크 관리"}
     )
     @GetMapping("/bookmarks/my")
-    public ResponseEntity<PaginatedResponseDTO<ResponsePlaceDTO>> getMyBookmarks(
-            @Parameter(description = "페이지당 항목 수", example = "10")
+    public ResponseEntity<PaginatedResponseDTO<ResponseBookmarkDTO>> getMyBookmarks(
             @RequestParam(defaultValue = "10") int numOfRows,
-
-            @Parameter(description = "페이지 번호 (1부터 시작)", example = "1")
             @RequestParam(defaultValue = "1") int pageNo,
 
             @Parameter(description = "정렬 기준 (T=제목, C=최신, R=별점)", example = "C")
@@ -141,7 +123,7 @@ public ResponseEntity<PaginatedResponseDTO<ResponsePlaceDTO>> getMyBookmarks(
         Pageable pageable = PageRequest.of(pageNo - 1, numOfRows, sort);
 
         String userEmail = authentication.getName();
-        Page<ResponsePlaceDTO> myBookmarks = bookmarkService.getMyBookmarks(userEmail, type, pageable);
+        Page<ResponseBookmarkDTO> myBookmarks = bookmarkService.getMyBookmarks(userEmail, type, pageable);
 
         return ResponseEntity.ok(PaginatedResponseDTO.of(myBookmarks));
     }
@@ -169,48 +151,9 @@ public ResponseEntity<BookmarkCountDTO> getMyBookmarkCount(
         return ResponseEntity.ok(new BookmarkCountDTO(type, count));
     }
 
-    @Operation(
-            summary = "내가 북마크한 placeId 목록 조회",
-            description = """
-                    사용자가 북마크한 모든 placeId를 반환합니다.
-                    프론트엔드에서 북마크 아이콘 표시 여부를 판단할 때 사용합니다.
-                    
-                    ### 응답 예시
-                    ```json
-                    ["126508", "264636", "125406"]
-                    ```
-                    
-                    ### 사용 예시
-                    ```javascript
-                    // 프론트엔드에서 활용
-                    const bookmarkedIds = await fetchMyBookmarkedIds();
-                    const isBookmarked = bookmarkedIds.includes(placeId);
-                    ```
-                    """,
-            tags = {"북마크 관리"}
-    )
-    @GetMapping("/bookmarks/my/ids")
-    public ResponseEntity<List<String>> getMyBookmarkedPlaceIds(
-            @Parameter(description = "북마크 타입 (선택사항)")
-            @RequestParam(required = false) BookmarkType type,
-
-            Authentication authentication
-    ) {
-        String userEmail = authentication.getName();
-
-        List<String> placeIds;
-        if (type != null) {
-            placeIds = bookmarkService.getMyBookmarkedPlaceIdsByType(userEmail, type);
-        } else {
-            placeIds = bookmarkService.getMyBookmarkedPlaceIds(userEmail);
-        }
-
-        return ResponseEntity.ok(placeIds);
-    }
-
     private Sort createBookmarkSort(String arrange) {
         return switch (arrange) {
-            case "T" -> Sort.by(Sort.Direction.ASC, "place.title"); // 제목 오름차순
+            case "T" -> Sort.by(Sort.Direction.ASC, "contentId.title"); // 제목 오름차순
             case "C" -> Sort.by(Sort.Direction.DESC, "createdAt");  // 최신 북마크 순
             case "R" -> Sort.by(Sort.Direction.DESC, "place.averageRating") // 별점 높은 순
                     .and(Sort.by(Sort.Direction.DESC, "createdAt"));

tour/src/main/java/com/jocketdan/tour/dto/ResponseBookmarkDTO.java

@@ -0,0 +1,38 @@
+package com.jocketdan.tour.dto;
+
+import com.jocketdan.tour.entity.OpenApiPlaceDetail;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+@Getter
+@AllArgsConstructor
+public class ResponseBookmarkDTO {
+
+    private String contentId;
+    private String title;
+    private String overview;
+    private String addr1;
+    private String addr2;
+    private Double mapx;
+    private Double mapy;
+    private String firstImage;
+    private String firstImage2;
+    private String homepage;
+    private String tel;
+
+    public static ResponseBookmarkDTO from(OpenApiPlaceDetail entity) {
+        return new ResponseBookmarkDTO(
+                entity.getContentId(),
+                entity.getTitle(),
+                entity.getOverview(),
+                entity.getAddr1(),
+                entity.getAddr2(),
+                entity.getMapx(),
+                entity.getMapy(),
+                entity.getFirstImage(),
+                entity.getFirstImage2(),
+                entity.getHomepage(),
+                entity.getTel()
+        );
+    }
+}

tour/src/main/java/com/jocketdan/tour/entity/Bookmark.java

@@ -40,15 +40,16 @@ public class Bookmark {
     @Column(name = "created_at", nullable = false)
     private LocalDateTime createdAt;
 
-    @Column(name = "place_id", nullable = false)
-    private String placeId;
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "content_id", nullable = false)
+    private OpenApiPlaceDetail contentId;
 
     @Column(name = "content_type_id", nullable = false)
     private Integer contentTypeId;
 
-    public Bookmark(String userEmail, String placeId, Integer contentTypeId) {
+    public Bookmark(String userEmail, OpenApiPlaceDetail contentId, Integer contentTypeId) {
         this.userEmail = userEmail;
-        this.placeId = placeId;
+        this.contentId = contentId;
         this.contentTypeId = contentTypeId;
         this.bookmarkType = determineBookmarkType(contentTypeId);
         this.createdAt = LocalDateTime.now();

tour/src/main/java/com/jocketdan/tour/entity/OpenApiPlaceDetail.java

@@ -0,0 +1,52 @@
+package com.jocketdan.tour.entity;
+
+import jakarta.persistence.Column;
+import jakarta.persistence.Entity;
+import jakarta.persistence.Id;
+import lombok.AccessLevel;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.experimental.FieldDefaults;
+
+@Entity
+@Getter
+@NoArgsConstructor
+@AllArgsConstructor
+@FieldDefaults(level = AccessLevel.PRIVATE)
+public class OpenApiPlaceDetail {
+
+    @Id
+    String contentId;
+    String title;
+
+    @Column(columnDefinition = "TEXT")
+    String overview;
+
+    String addr1;
+    String addr2;
+    String zipcode;
+
+    Double mapx;
+    Double mapy;
+
+    String contentTypeId;
+
+    String firstImage;
+    String firstImage2;
+
+    String createdTime;
+    String modifiedTime;
+
+    String cat1;
+    String cat2;
+    String cat3;
+
+    String areaCode;
+    String sigunguCode;
+
+    String homepage;
+    String tel;
+    String telName;
+    String cpyrhtDivCd;
+}

tour/src/main/java/com/jocketdan/tour/repository/BookmarkRepository.java

@@ -2,33 +2,32 @@
 
 import com.jocketdan.tour.entity.Bookmark;
 import com.jocketdan.tour.entity.BookmarkType;
+import com.jocketdan.tour.entity.OpenApiPlaceDetail;
 import org.springframework.data.domain.Page;
 import org.springframework.data.domain.Pageable;
 import org.springframework.data.jpa.repository.JpaRepository;
 import org.springframework.data.jpa.repository.Query;
 import org.springframework.data.repository.query.Param;
 
 import java.util.List;
-import java.util.Optional;
 
 public interface BookmarkRepository extends JpaRepository<Bookmark, Long> {
 
-    boolean existsByUserEmailAndPlaceId(String userEmail, String placeId);
+    boolean existsByUserEmailAndContentId(String userEmail, OpenApiPlaceDetail contentId);
 
-    Optional<Bookmark> findByUserEmailAndPlaceId(String userEmail, String placeId);
-
-    List<Bookmark> findByUserEmailAndPlaceIdIn(String userEmail, List<String> placeIds);
-
-    Page<Bookmark> findByUserEmailAndBookmarkType(String userEmail, BookmarkType bookmarkType, Pageable pageable);
-
-    Page<Bookmark> findByUserEmail(String userEmail, Pageable pageable);
+    List<Bookmark> findByUserEmailAndContentId_ContentIdIn(String userEmail, List<String> contentIds);
 
     @Query("SELECT COUNT(b) FROM Bookmark b WHERE b.userEmail = :email AND b.bookmarkType = :type")
     long countByUserEmailAndType(@Param("email") String email, @Param("type") BookmarkType type);
 
-    @Query("SELECT b.placeId FROM Bookmark b WHERE b.userEmail = :email")
-    List<String> findPlaceIdsByUserEmail(@Param("email") String email);
-
-    @Query("SELECT b.placeId FROM Bookmark b WHERE b.userEmail = :email AND b.bookmarkType = :type")
-    List<String> findPlaceIdsByUserEmailAndType(@Param("email") String email, @Param("type") BookmarkType type);
+    @Query("""
+            SELECT b FROM Bookmark b
+            JOIN FETCH b.contentId c
+            WHERE b.userEmail = :userEmail
+            AND (:type IS NULL OR b.bookmarkType = :type)
+            """)
+    Page<Bookmark> findByUserEmailWithContentId(
+            @Param("userEmail") String userEmail,
+            @Param("type") BookmarkType type,
+            Pageable pageable);
 }

tour/src/main/java/com/jocketdan/tour/repository/OpenApiPlaceDetailRepository.java

@@ -0,0 +1,10 @@
+package com.jocketdan.tour.repository;
+
+import com.jocketdan.tour.entity.OpenApiPlaceDetail;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+import java.util.Optional;
+
+public interface OpenApiPlaceDetailRepository extends JpaRepository<OpenApiPlaceDetail, String> {
+    Optional<OpenApiPlaceDetail> findByContentId(String placeId);
+}