[feat] 전체 피드 조회 api 구현

src/main/java/konkuk/thip/common/entity/BaseJpaEntity.java

@@ -5,6 +5,7 @@
 import com.fasterxml.jackson.databind.annotation.JsonSerialize;
 import com.fasterxml.jackson.datatype.jsr310.deser.LocalDateDeserializer;
 import com.fasterxml.jackson.datatype.jsr310.ser.LocalDateSerializer;
+import com.google.common.annotations.VisibleForTesting;
 import jakarta.persistence.*;
 import lombok.Getter;
 import lombok.Setter;
@@ -38,4 +39,9 @@ public abstract class BaseJpaEntity {
     @Enumerated(EnumType.STRING)
     @Column(nullable = false)
     private StatusType status = StatusType.ACTIVE;
-}
+
+    @VisibleForTesting
+    protected void setCreatedAt(LocalDateTime createdAt) {
+        this.createdAt = createdAt;
+    }
+}

src/main/java/konkuk/thip/feed/adapter/in/web/FeedQueryController.java

@@ -1,10 +1,24 @@
 package konkuk.thip.feed.adapter.in.web;
 
+import konkuk.thip.common.dto.BaseResponse;
+import konkuk.thip.common.security.annotation.UserId;
+import konkuk.thip.feed.adapter.in.web.response.FeedShowAllResponse;
+import konkuk.thip.feed.application.port.in.FeedShowAllUseCase;
 import lombok.RequiredArgsConstructor;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestParam;
 import org.springframework.web.bind.annotation.RestController;
 
 @RestController
 @RequiredArgsConstructor
 public class FeedQueryController {
 
+    private final FeedShowAllUseCase feedShowAllUseCase;
+
+    @GetMapping("/feeds")
+    public BaseResponse<FeedShowAllResponse> showAllFeeds(
+            @UserId final Long userId,
+            @RequestParam(value = "cursor", required = false) final String cursor) {
+        return BaseResponse.ok(feedShowAllUseCase.showAllFeeds(userId, cursor));
+    }
 }

src/main/java/konkuk/thip/feed/adapter/in/web/response/FeedShowAllResponse.java

@@ -0,0 +1,27 @@
+package konkuk.thip.feed.adapter.in.web.response;
+
+import java.util.List;
+
+public record FeedShowAllResponse(
+        List<FeedDto> feedList,
+        String nextCursor,
+        boolean isLast
+) {
+    public record FeedDto(
+            Long feedId,
+            Long creatorId,
+            String creatorNickname,
+            String creatorProfileImageUrl,
+            String alias,
+            String postDate,
+            String isbn,
+            String bookTitle,
+            String bookAuthor,
+            String contentBody,
+            String[] contentUrls,
+            int likeCount,
+            int commentCount,
+            boolean isSaved,
+            boolean isLiked
+    ) { }
+}

src/main/java/konkuk/thip/feed/adapter/out/jpa/FeedJpaEntity.java

@@ -1,6 +1,7 @@
 
 package konkuk.thip.feed.adapter.out.jpa;
 
+import com.google.common.annotations.VisibleForTesting;
 import jakarta.persistence.*;
 import konkuk.thip.book.adapter.out.jpa.BookJpaEntity;
 import konkuk.thip.feed.domain.Feed;
@@ -11,6 +12,7 @@
 import lombok.Getter;
 import lombok.NoArgsConstructor;
 
+import java.time.LocalDateTime;
 import java.util.List;
 
 @Entity
@@ -49,4 +51,9 @@ public void updateFrom(Feed feed) {
         this.likeCount = feed.getLikeCount();
         this.commentCount = feed.getCommentCount();
     }
+
+    @VisibleForTesting
+    public void setCreatedAt(LocalDateTime newCreatedAt) {
+        super.setCreatedAt(newCreatedAt);
+    }
 }

src/main/java/konkuk/thip/feed/adapter/out/persistence/FeedQueryPersistenceAdapter.java

@@ -1,11 +1,16 @@
 package konkuk.thip.feed.adapter.out.persistence;
 
+import konkuk.thip.common.util.Cursor;
+import konkuk.thip.common.util.CursorBasedList;
 import konkuk.thip.feed.adapter.out.mapper.FeedMapper;
 import konkuk.thip.feed.adapter.out.persistence.repository.FeedJpaRepository;
 import konkuk.thip.feed.application.port.out.FeedQueryPort;
+import konkuk.thip.feed.application.port.out.dto.FeedQueryDto;
 import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Repository;
 
+import java.time.LocalDateTime;
+import java.util.List;
 import java.util.Set;
 
 @Repository
@@ -19,4 +24,28 @@ public class FeedQueryPersistenceAdapter implements FeedQueryPort {
     public Set<Long> findUserIdsByBookId(Long bookId) {
         return feedJpaRepository.findUserIdsByBookId(bookId);
     }
+
+    @Override
+    public CursorBasedList<FeedQueryDto> findFeedsByFollowingPriority(Long userId, Cursor cursor) {
+        Integer lastPriority = cursor.isFirstRequest() ? null : cursor.getInteger(0);
+        LocalDateTime lastCreatedAt = cursor.isFirstRequest() ? null : cursor.getLocalDateTime(1);
+        int size = cursor.getPageSize();
+
+        List<FeedQueryDto> feedQueryDtos = feedJpaRepository.findFeedsByFollowingPriority(userId, lastPriority, lastCreatedAt, size);
+
+        return CursorBasedList.of(feedQueryDtos, size, feedQueryDto -> {
+            Cursor nextCursor = new Cursor(List.of(
+                    Boolean.TRUE.equals(feedQueryDto.isPriorityFeed()) ? "1" : "0",
+                    feedQueryDto.createdAt().toString()
+            ));
+            return nextCursor.toEncodedString();
+        });
+    }
+
+    @Override
+    public CursorBasedList<FeedQueryDto> findLatestFeedsByCreatedAt(Long userId, LocalDateTime lastCreatedAt, int size) {
+        List<FeedQueryDto> feedQueryDtos = feedJpaRepository.findLatestFeedsByCreatedAt(userId, lastCreatedAt, size);
+
+        return CursorBasedList.of(feedQueryDtos, size, feedQueryDto -> feedQueryDto.createdAt().toString());
+    }
 }

src/main/java/konkuk/thip/feed/adapter/out/persistence/repository/FeedQueryRepository.java

@@ -1,7 +1,15 @@
 package konkuk.thip.feed.adapter.out.persistence.repository;
 
+import konkuk.thip.feed.application.port.out.dto.FeedQueryDto;
+
+import java.time.LocalDateTime;
+import java.util.List;
 import java.util.Set;
 
 public interface FeedQueryRepository {
     Set<Long> findUserIdsByBookId(Long bookId);
-}
+
+    List<FeedQueryDto> findFeedsByFollowingPriority(Long userId, Integer lastPriority, LocalDateTime lastCreatedAt, int size);
+
+    List<FeedQueryDto> findLatestFeedsByCreatedAt(Long userId, LocalDateTime lastCreatedAt, int size);
+}

src/main/java/konkuk/thip/feed/adapter/out/persistence/repository/FeedQueryRepositoryImpl.java

@@ -1,22 +1,46 @@
 package konkuk.thip.feed.adapter.out.persistence.repository;
 
+import com.querydsl.core.Tuple;
+import com.querydsl.core.types.dsl.BooleanExpression;
+import com.querydsl.core.types.dsl.CaseBuilder;
+import com.querydsl.core.types.dsl.Expressions;
+import com.querydsl.core.types.dsl.NumberExpression;
 import com.querydsl.jpa.impl.JPAQueryFactory;
+import konkuk.thip.book.adapter.out.jpa.QBookJpaEntity;
+import konkuk.thip.common.entity.StatusType;
+import konkuk.thip.feed.adapter.out.jpa.ContentJpaEntity;
+import konkuk.thip.feed.adapter.out.jpa.FeedJpaEntity;
+import konkuk.thip.feed.adapter.out.jpa.QContentJpaEntity;
 import konkuk.thip.feed.adapter.out.jpa.QFeedJpaEntity;
+import konkuk.thip.feed.application.port.out.dto.FeedQueryDto;
+import konkuk.thip.user.adapter.out.jpa.QAliasJpaEntity;
+import konkuk.thip.user.adapter.out.jpa.QFollowingJpaEntity;
+import konkuk.thip.user.adapter.out.jpa.QUserJpaEntity;
 import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Repository;
 
+import java.time.LocalDateTime;
 import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
 import java.util.Set;
+import java.util.stream.Collectors;
 
 @Repository
 @RequiredArgsConstructor
 public class FeedQueryRepositoryImpl implements FeedQueryRepository {
 
     private final JPAQueryFactory jpaQueryFactory;
 
+    private final QFeedJpaEntity feed = QFeedJpaEntity.feedJpaEntity;
+    private final QContentJpaEntity content = QContentJpaEntity.contentJpaEntity;
+    private final QUserJpaEntity user = QUserJpaEntity.userJpaEntity;
+    private final QAliasJpaEntity alias = QAliasJpaEntity.aliasJpaEntity;
+    private final QBookJpaEntity book = QBookJpaEntity.bookJpaEntity;
+    private final QFollowingJpaEntity following = QFollowingJpaEntity.followingJpaEntity;
+
     @Override
     public Set<Long> findUserIdsByBookId(Long bookId) {
-        QFeedJpaEntity feed = QFeedJpaEntity.feedJpaEntity;
         Set<Long> userIds = new HashSet<>(
                 jpaQueryFactory
                         .select(feed.userJpaEntity.userId)
@@ -27,4 +51,172 @@ public Set<Long> findUserIdsByBookId(Long bookId) {
         );
         return userIds;
     }
+
+    @Override
+    public List<FeedQueryDto> findFeedsByFollowingPriority(Long userId, Integer lastPriority, LocalDateTime lastCreatedAt, int size) {
+        // 1) 게시글 ID만 우선순위 + 페이징으로 조회
+        List<Tuple> tuples = fetchFeedIdsAndPriorityByFollowingPriority(userId, lastPriority, lastCreatedAt, size);
+        if (tuples.isEmpty()) {
+            return List.of();       // early return
+        }
+
+        // 2) 상세 엔티티를 ID 순으로 조회 후 정렬
+        List<Long> feedIds = tuples.stream()
+                .map(tuple -> tuple.get(0, Long.class))
+                .toList();
+        Map<Long, Integer> priorityMap = tuples.stream()
+                .collect(Collectors.toMap(
+                        tuple -> tuple.get(0, Long.class),
+                        tuple -> tuple.get(1, Integer.class)
+                ));
+
+        List<FeedJpaEntity> entities = fetchFeedEntitiesByIds(feedIds);
+        Map<Long, FeedJpaEntity> entityMap = entities.stream()
+                .collect(Collectors.toMap(FeedJpaEntity::getPostId, e -> e));
+        List<FeedJpaEntity> ordered = feedIds.stream()
+                .map(entityMap::get)
+                .toList();
+
+        // 3) DTO 변환
+        return ordered.stream()
+                .map(e -> {
+                    String[] urls = e.getContentList().stream()
+                            .map(ContentJpaEntity::getContentUrl)
+                            .toArray(String[]::new);
+                    boolean isPriority = priorityMap.get(e.getPostId()) == 1;
+
+                    return FeedQueryDto.builder()
+                            .feedId(e.getPostId())
+                            .creatorId(e.getUserJpaEntity().getUserId())
+                            .creatorNickname(e.getUserJpaEntity().getNickname())
+                            .creatorProfileImageUrl(e.getUserJpaEntity().getImageUrl())
+                            .alias(e.getUserJpaEntity().getAliasForUserJpaEntity().getValue())
+                            .createdAt(e.getCreatedAt())
+                            .isbn(e.getBookJpaEntity().getIsbn())
+                            .bookTitle(e.getBookJpaEntity().getTitle())
+                            .bookAuthor(e.getBookJpaEntity().getAuthorName())
+                            .contentBody(e.getContent())
+                            .contentUrls(urls)
+                            .likeCount(e.getLikeCount())
+                            .commentCount(e.getCommentCount())
+                            .isPriorityFeed(isPriority)
+                            .build();
+                })
+                .toList();
+    }
+
+    @Override
+    public List<FeedQueryDto> findLatestFeedsByCreatedAt(Long userId, LocalDateTime lastCreatedAt, int size) {
+        // 1) 게시글 ID만 최신순 페이징으로 조회
+        List<Long> feedIds = fetchFeedIdsLatest(userId, lastCreatedAt, size);
+        if (feedIds.isEmpty()) {
+            return List.of();       // early return
+        }
+
+        // 2) 상세 엔티티 조회 및 정렬
+        List<FeedJpaEntity> entities = fetchFeedEntitiesByIds(feedIds);
+        Map<Long, FeedJpaEntity> entityMap = entities.stream()
+                .collect(Collectors.toMap(FeedJpaEntity::getPostId, e -> e));
+        List<FeedJpaEntity> ordered = feedIds.stream()
+                .map(entityMap::get)
+                .toList();
+
+        // 3) DTO 변환
+        return ordered.stream()
+                .map(e -> {
+                    String[] urls = e.getContentList().stream()
+                            .map(ContentJpaEntity::getContentUrl)
+                            .toArray(String[]::new);
+                    return FeedQueryDto.builder()
+                            .feedId(e.getPostId())
+                            .creatorId(e.getUserJpaEntity().getUserId())
+                            .creatorNickname(e.getUserJpaEntity().getNickname())
+                            .creatorProfileImageUrl(e.getUserJpaEntity().getImageUrl())
+                            .alias(e.getUserJpaEntity().getAliasForUserJpaEntity().getValue())
+                            .createdAt(e.getCreatedAt())
+                            .isbn(e.getBookJpaEntity().getIsbn())
+                            .bookTitle(e.getBookJpaEntity().getTitle())
+                            .bookAuthor(e.getBookJpaEntity().getAuthorName())
+                            .contentBody(e.getContent())
+                            .contentUrls(urls)
+                            .likeCount(e.getLikeCount())
+                            .commentCount(e.getCommentCount())
+                            .build();
+                })
+                .toList();
+    }
+
+    /**
+     * ID 목록만 우선순위 & 커서 페이징으로 조회
+     */
+    private List<Tuple> fetchFeedIdsAndPriorityByFollowingPriority(Long userId, Integer lastPriority, LocalDateTime lastCreatedAt, int size) {
+        // 내가 작성한 모든 글 + 내가 팔로우하는 다른 유저가 작성한 공개글을 우선적으로 최신순 조회
+        // 이후 내가 팔로우하지 않는 다른 유저가 작성한 공개글을 최신순 조회
+        NumberExpression<Integer> priority = new CaseBuilder()
+                .when(feed.userJpaEntity.userId.eq(userId)).then(1)
+                .when(
+                        following.userJpaEntity.userId.eq(userId)
+                                .and(following.followingUserJpaEntity.userId.eq(feed.userJpaEntity.userId))
+                                .and(feed.isPublic.eq(true))
+                ).then(1)
+                .otherwise(0);
+
+        // 복합 커서 조건: 우선순위 및 생성일시 기준
+        BooleanExpression cursorCondition = (lastPriority != null && lastCreatedAt != null)
+                ? priority.lt(lastPriority)
+                .or(priority.eq(lastPriority)
+                        .and(feed.createdAt.lt(lastCreatedAt)))
+                : Expressions.TRUE;
+
+        return jpaQueryFactory
+                .select(feed.postId, priority)
+                .distinct()
+                .from(feed)
+                .leftJoin(following)
+                .on(following.userJpaEntity.userId.eq(userId)
+                        .and(following.followingUserJpaEntity.userId.eq(feed.userJpaEntity.userId)))
+                .where(
+                        // ACTIVE 인 feed & (내가 작성한 글 or 다른 유저가 작성한 공개글) & cursorCondition
+                        feed.status.eq(StatusType.ACTIVE),
+                        feed.userJpaEntity.userId.eq(userId).or(feed.isPublic.eq(true)),
+                        cursorCondition
+                )
+                .orderBy(priority.desc(), feed.createdAt.desc())
+                .limit(size + 1)
+                .fetch();
+    }
+
+    /**
+     * ID 목록만 최신순 커서 페이징으로 조회
+     */
+    private List<Long> fetchFeedIdsLatest(Long userId, LocalDateTime lastCreatedAt, int size) {
+        return jpaQueryFactory
+                .select(feed.postId)
+                .distinct()
+                .from(feed)
+                .where(
+                        // ACTIVE 인 feed & (내가 작성한 글 or 다른 유저가 작성한 공개글) & cursorCondition
+                        feed.status.eq(StatusType.ACTIVE),
+                        feed.userJpaEntity.userId.eq(userId).or(feed.isPublic.eq(true)),
+                        lastCreatedAt != null ? feed.createdAt.lt(lastCreatedAt) : Expressions.TRUE
+                )
+                .orderBy(feed.createdAt.desc())
+                .limit(size + 1)
+                .fetch();
+    }
+
+    /**
+     * 주어진 ID 목록으로 엔티티를 페치조인 후 조회
+     */
+    private List<FeedJpaEntity> fetchFeedEntitiesByIds(List<Long> ids) {
+        return jpaQueryFactory
+                .select(feed).distinct()
+                .from(feed)
+                .leftJoin(feed.contentList, content).fetchJoin()
+                .leftJoin(feed.userJpaEntity, user).fetchJoin()
+                .leftJoin(user.aliasForUserJpaEntity, alias).fetchJoin()
+                .leftJoin(feed.bookJpaEntity, book).fetchJoin()
+                .where(feed.postId.in(ids))
+                .fetch();
+    }
 }