⚡ MarkSphere v1.0.6

북마크 로딩 방식 변경(커서 기반)
QR코드 URL 수정
댓글, 북마크 등록 시 DB에 생성된 정보 반환
북마크 로딩 시 최신순으로 로딩

Author: son0307

src/main/java/com/sonkim/bookmarking/domain/bookmark/controller/TeamBookmarkController.java

@@ -2,11 +2,10 @@
 
 import com.sonkim.bookmarking.auth.entity.UserDetailsImpl;
 import com.sonkim.bookmarking.common.aop.Idempotent;
-import com.sonkim.bookmarking.common.dto.PageResponseDto;
+import com.sonkim.bookmarking.common.dto.CursorResultDto;
 import com.sonkim.bookmarking.domain.bookmark.dto.BookmarkRequestDto;
 import com.sonkim.bookmarking.domain.bookmark.dto.BookmarkResponseDto;
 import com.sonkim.bookmarking.domain.bookmark.dto.BookmarkSearchCond;
-import com.sonkim.bookmarking.domain.bookmark.entity.Bookmark;
 import com.sonkim.bookmarking.domain.bookmark.service.BookmarkService;
 import io.swagger.v3.oas.annotations.Parameter;
 import io.swagger.v3.oas.annotations.Operation;
@@ -15,16 +14,12 @@
 import io.swagger.v3.oas.annotations.tags.Tag;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
-import org.springframework.data.domain.Pageable;
-import org.springframework.data.web.PageableDefault;
 import org.springframework.http.HttpStatus;
 import org.springframework.http.ResponseEntity;
 import org.springframework.security.core.annotation.AuthenticationPrincipal;
 import org.springframework.stereotype.Controller;
 import org.springframework.web.bind.annotation.*;
 
-import java.util.Map;
-
 @Tag(name = "그룹 북마크 관리", description = "그룹 내 북마크 생성 및 조회 API")
 @Slf4j
 @RequiredArgsConstructor
@@ -42,58 +37,58 @@ public class TeamBookmarkController {
     })
     @PostMapping("/{groupId}/bookmarks")
     @Idempotent
-    public ResponseEntity<Map<String, Object>> createBookmark(@AuthenticationPrincipal UserDetailsImpl userDetails,
+    public ResponseEntity<BookmarkResponseDto> createBookmark(@AuthenticationPrincipal UserDetailsImpl userDetails,
                                             @PathVariable Long groupId,
                                             @RequestBody BookmarkRequestDto bookmarkRequestDto) {
         log.info("userId: {}, url: {} 북마크 생성 요청", userDetails.getId(), bookmarkRequestDto.getUrl());
-        Bookmark bookmark = bookmarkService.createBookmark(userDetails.getId(), groupId, bookmarkRequestDto);
-
-        Map<String, Object> response = Map.of(
-                "message", "Bookmark created successfully",
-                "bookmarkId", bookmark.getId()
-        );
+        BookmarkResponseDto responseDto = bookmarkService.createBookmark(userDetails.getId(), groupId, bookmarkRequestDto);
 
-        return ResponseEntity.status(HttpStatus.CREATED).body(response);
+        return ResponseEntity.status(HttpStatus.CREATED).body(responseDto);
     }
 
-    @Operation(summary = "그룹 내 모든 북마크 조회 (페이징)",
+    @Operation(summary = "그룹 내 모든 북마크 조회 (커서 페이징)",
             description = "특정 그룹에 속한 모든 북마크를 페이징하여 조회합니다.",
             parameters = {
-                    @Parameter(name = "page", description = "표시할 페이지 (1부터 시작)")
+                    @Parameter(name = "cursor", description = "다음 페이지를 위한 커서 ID(마지막으로 조회한 북마크 ID, 첫 페이지는 null)"),
+                    @Parameter(name = "size", description = "한 페이지당 항목 수")
             })
     @ApiResponse(responseCode = "200", description = "북마크 목록 조회 성공")
     @GetMapping("/{groupId}/bookmarks")
-    public ResponseEntity<PageResponseDto<BookmarkResponseDto>> getBookmarksOfGroup(
+    public ResponseEntity<CursorResultDto<BookmarkResponseDto>> getBookmarksOfGroup(
             @AuthenticationPrincipal UserDetailsImpl userDetails,
             @PathVariable("groupId") Long groupId,
             @RequestParam(required = false) String keyword,
             @RequestParam(required = false) Long tagId,
             @RequestParam(required = false) Long categoryId,
-            @Parameter(hidden = true) @PageableDefault(sort = "createdAt") Pageable pageable) {
+            @RequestParam(required = false) Long cursor,
+            @RequestParam(required = false, defaultValue = "10") int size
+    ) {
         // 검색 조건 DTO 생성
         BookmarkSearchCond cond = BookmarkSearchCond.builder()
                 .keyword(keyword)
                 .tagId(tagId)
                 .categoryId(categoryId)
                 .build();
 
-        PageResponseDto<BookmarkResponseDto> bookmarkPage = bookmarkService.searchBookmarks(userDetails.getId(), groupId, cond, pageable);
+        CursorResultDto<BookmarkResponseDto> bookmarkPage = bookmarkService.searchBookmarks(userDetails.getId(), groupId, cond, cursor, size);
         return ResponseEntity.ok(bookmarkPage);
     }
 
-    @Operation(summary = "지도 표시용 북마크 목록 조회 (필터링, 페이징)",
+    @Operation(summary = "지도 표시용 북마크 목록 조회 (필터링, 커서 페이징)",
             description = "특정 그룹에서 위치 정보가 있는 북마크를 조건(카테고리, 키워드, 태그)에 따라 필터링하여 조회합니다.",
             parameters = {
-                    @Parameter(name = "page", description = "표시할 페이지 (1부터 시작)")
+                    @Parameter(name = "cursor", description = "다음 페이지를 위한 커서 ID(마지막으로 조회한 북마크 ID, 첫 페이지는 null)"),
+                    @Parameter(name = "size", description = "한 페이지당 항목 수")
             })
     @GetMapping("/{groupId}/bookmarks/map")
-    public ResponseEntity<PageResponseDto<BookmarkResponseDto>> getBookmarksForMap(
+    public ResponseEntity<CursorResultDto<BookmarkResponseDto>> getBookmarksForMap(
             @AuthenticationPrincipal UserDetailsImpl userDetails,
             @Parameter(description = "북마크를 조회할 그룹 ID") @PathVariable("groupId") Long groupId,
+            @RequestParam(required = false) String keyword,
             @RequestParam(required = false) Long categoryId,
             @RequestParam(required = false) Long tagId,
-            @RequestParam(required = false) String keyword,
-            @Parameter(hidden = true) @PageableDefault(size = 10) Pageable pageable
+            @RequestParam(required = false) Long cursor,
+            @RequestParam(required = false, defaultValue = "10") int size
     ) {
         // 검색 조건 DTO 생성
         BookmarkSearchCond cond = BookmarkSearchCond.builder()
@@ -103,7 +98,7 @@ public ResponseEntity<PageResponseDto<BookmarkResponseDto>> getBookmarksForMap(
                 .forMap(true)
                 .build();
 
-        PageResponseDto<BookmarkResponseDto> bookmarks = bookmarkService.searchBookmarks(userDetails.getId(), groupId, cond, pageable);
+        CursorResultDto<BookmarkResponseDto> bookmarks = bookmarkService.searchBookmarks(userDetails.getId(), groupId, cond, cursor, size);
         return ResponseEntity.ok(bookmarks);
     }
 }

src/main/java/com/sonkim/bookmarking/domain/bookmark/dto/LikedBookmarkWrapper.java

@@ -0,0 +1,12 @@
+package com.sonkim.bookmarking.domain.bookmark.dto;
+
+import com.sonkim.bookmarking.domain.bookmark.entity.Bookmark;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+
+@Data
+@AllArgsConstructor
+public class LikedBookmarkWrapper {
+    private Bookmark bookmark;
+    private Long bookmarkLikeId;
+}

src/main/java/com/sonkim/bookmarking/domain/bookmark/entity/BookmarkLike.java

@@ -25,5 +25,4 @@ public class BookmarkLike {
     @ManyToOne(fetch = FetchType.LAZY)
     @JoinColumn(name = "bookmark_id", nullable = false)
     private Bookmark bookmark;
-
 }

src/main/java/com/sonkim/bookmarking/domain/bookmark/repository/BookmarkRepositoryCustom.java

@@ -1,16 +1,16 @@
 package com.sonkim.bookmarking.domain.bookmark.repository;
 
 import com.sonkim.bookmarking.domain.bookmark.dto.BookmarkSearchCond;
+import com.sonkim.bookmarking.domain.bookmark.dto.LikedBookmarkWrapper;
 import com.sonkim.bookmarking.domain.bookmark.entity.Bookmark;
-import org.springframework.data.domain.Page;
-import org.springframework.data.domain.Pageable;
 import org.springframework.data.repository.query.Param;
 
 import java.util.Optional;
+import java.util.List;
 
 public interface BookmarkRepositoryCustom {
-    // 검색 조건을 받아와 검색 처리
-    Page<Bookmark> search(Long teamId, BookmarkSearchCond cond, Pageable pageable);
+    // 검색 조건을 받아와 x검색 처리
+    List<Bookmark> search(Long teamId, BookmarkSearchCond cond, Long cursorId, int size);
 
     // 북마크 조회 시 북마크-태그와 태그 정보 모두 가져오는 쿼리
     Optional<Bookmark> findByIdWithTags(@Param("id") Long id);
@@ -19,5 +19,8 @@ public interface BookmarkRepositoryCustom {
     void bulkSetCategoryToNull(@Param("categoryId") Long categoryId);
 
     // 특정 사용자가 '좋아요'를 누른 북마크 정보 조회
-    Page<Bookmark> findLikedBookmarksByUser_Id(Long userId, Pageable pageable);
+    List<LikedBookmarkWrapper> findLikedBookmarksByUser_Id(Long userId, Long cursorId, int size);
+
+    // 특정 사용자가 작성한 북마크 정보 조회
+    List<Bookmark> findMyBookmarksByUser_Id(Long userId, Long cursorId, int size);
 }

src/main/java/com/sonkim/bookmarking/domain/bookmark/repository/BookmarkRepositoryCustomImpl.java

@@ -1,16 +1,14 @@
 package com.sonkim.bookmarking.domain.bookmark.repository;
 
+import com.querydsl.core.types.Projections;
+import com.sonkim.bookmarking.domain.bookmark.dto.LikedBookmarkWrapper;
 import jakarta.persistence.EntityManager;
 import com.querydsl.core.types.dsl.BooleanExpression;
-import com.querydsl.jpa.impl.JPAQuery;
 import com.querydsl.jpa.impl.JPAQueryFactory;
 import com.sonkim.bookmarking.domain.bookmark.dto.BookmarkSearchCond;
 import com.sonkim.bookmarking.domain.bookmark.entity.Bookmark;
 import com.sonkim.bookmarking.domain.category.entity.Category;
 import lombok.RequiredArgsConstructor;
-import org.springframework.data.domain.Page;
-import org.springframework.data.domain.Pageable;
-import org.springframework.data.support.PageableExecutionUtils;
 
 import java.util.List;
 import java.util.Optional;
@@ -27,7 +25,7 @@ public class BookmarkRepositoryCustomImpl implements BookmarkRepositoryCustom {
     private final EntityManager em;
 
     @Override
-    public Page<Bookmark> search(Long teamId, BookmarkSearchCond cond, Pageable pageable) {
+    public List<Bookmark> search(Long teamId, BookmarkSearchCond cond, Long cursorId, int size) {
         List<Bookmark> content = queryFactory
                 .select(bookmark)
                 .from(bookmark)
@@ -37,26 +35,15 @@ public Page<Bookmark> search(Long teamId, BookmarkSearchCond cond, Pageable page
                         keywordContain(cond.getKeyword()),
                         tagIdEq(cond.getTagId()),
                         categoryIdEq(cond.getCategoryId()),
-                        locationIsNotNull(cond.getForMap())
+                        locationIsNotNull(cond.getForMap()),
+                        cursorIdLessThen(cursorId)
                 )
                 .distinct()
-                .offset(pageable.getOffset())
-                .limit(pageable.getPageSize())
+                .limit(size)
+                .orderBy(bookmark.id.desc())
                 .fetch();
 
-        JPAQuery<Long> countQuery = queryFactory
-                .select(bookmark.countDistinct())
-                .from(bookmark)
-                .leftJoin(bookmark.bookmarkTags, bookmarkTag)
-                .where(
-                        bookmark.team.id.eq(teamId),
-                        keywordContain(cond.getKeyword()),
-                        tagIdEq(cond.getCategoryId()),
-                        categoryIdEq(cond.getCategoryId()),
-                        locationIsNotNull(cond.getForMap())
-                );
-
-        return PageableExecutionUtils.getPage(content, pageable, countQuery::fetchOne);
+        return content;
     }
 
     @Override
@@ -85,23 +72,34 @@ public void bulkSetCategoryToNull(Long categoryId) {
     }
 
     @Override
-    public Page<Bookmark> findLikedBookmarksByUser_Id(Long userId, Pageable pageable) {
-        List<Bookmark> content = queryFactory
-                .select(bookmark)
-                .from(bookmark)
-                .join(bookmark.bookmarkLikes, bookmarkLike)
-                .where(bookmarkLike.user.id.eq(userId))
-                .offset(pageable.getOffset())
-                .limit(pageable.getPageSize())
+    public List<Bookmark> findMyBookmarksByUser_Id(Long userId, Long cursorId, int size) {
+        return queryFactory
+                .selectFrom(bookmark)
+                .where(
+                        bookmark.user.id.eq(userId),
+                        cursorIdLessThen(cursorId)
+                )
+                .orderBy(bookmark.id.desc())
+                .limit(size)
                 .fetch();
+    }
 
-        JPAQuery<Long> countQuery = queryFactory
-                .select(bookmark.count())
-                .from(bookmark)
-                .join(bookmark.bookmarkLikes, bookmarkLike)
-                .where(bookmarkLike.user.id.eq(userId));
-
-        return PageableExecutionUtils.getPage(content, pageable, countQuery::fetchOne);
+    @Override
+    public List<LikedBookmarkWrapper> findLikedBookmarksByUser_Id(Long userId, Long cursorId, int size) {
+        return queryFactory
+                .select(Projections.constructor(LikedBookmarkWrapper.class,
+                        bookmark,
+                        bookmarkLike.id
+                ))
+                .from(bookmarkLike)
+                .join(bookmarkLike.bookmark, bookmark)
+                .where(
+                        bookmarkLike.user.id.eq(userId),
+                        bookmarkLikedCursorIdLessThen(cursorId)
+                )
+                .orderBy(bookmarkLike.id.desc())
+                .limit(size)
+                .fetch();
     }
 
     private BooleanExpression locationIsNotNull(Boolean forMap) {
@@ -120,4 +118,12 @@ private BooleanExpression categoryIdEq(Long categoryId) {
     private BooleanExpression tagIdEq(Long tagId) {
         return tagId != null ? bookmarkTag.tag.id.eq(tagId) : null;
     }
+
+    private BooleanExpression cursorIdLessThen(Long cursorId) {
+        return cursorId != null ? bookmark.id.lt(cursorId) : null;
+    }
+
+    private BooleanExpression bookmarkLikedCursorIdLessThen(Long cursorId) {
+        return cursorId != null ? bookmarkLike.id.lt(cursorId) : null;
+    }
 }