[BE] feat: 상품에 대한 리뷰 목록 조회 동적 쿼리 구현 및 API 성능 개선

backend/src/main/java/com/funeat/review/application/ReviewService.java

@@ -27,6 +27,7 @@
 import com.funeat.review.dto.ReviewCreateRequest;
 import com.funeat.review.dto.ReviewFavoriteRequest;
 import com.funeat.review.dto.SortingReviewDto;
+import com.funeat.review.dto.SortingReviewRequest;
 import com.funeat.review.dto.SortingReviewsResponse;
 import com.funeat.review.exception.ReviewException.NotAuthorOfReviewException;
 import com.funeat.review.exception.ReviewException.ReviewNotFoundException;
@@ -50,9 +51,10 @@
 @Transactional(readOnly = true)
 public class ReviewService {
 
-    private static final int TOP = 0;
+    private static final int START = 0;
     private static final int ONE = 1;
     private static final String EMPTY_URL = "";
+    private static final int REVIEW_PAGE_SIZE = 10;
 
     private final ReviewRepository reviewRepository;
     private final TagRepository tagRepository;
@@ -61,20 +63,23 @@ public class ReviewService {
     private final ProductRepository productRepository;
     private final ReviewFavoriteRepository reviewFavoriteRepository;
     private final ImageUploader imageUploader;
+    private final SortingReviewService sortingReviewService;
     private final ApplicationEventPublisher eventPublisher;
 
     public ReviewService(final ReviewRepository reviewRepository, final TagRepository tagRepository,
                          final ReviewTagRepository reviewTagRepository, final MemberRepository memberRepository,
                          final ProductRepository productRepository,
                          final ReviewFavoriteRepository reviewFavoriteRepository,
-                         final ImageUploader imageUploader, final ApplicationEventPublisher eventPublisher) {
+                         final ImageUploader imageUploader, final SortingReviewService sortingReviewService,
+                         final ApplicationEventPublisher eventPublisher) {
         this.reviewRepository = reviewRepository;
         this.tagRepository = tagRepository;
         this.reviewTagRepository = reviewTagRepository;
         this.memberRepository = memberRepository;
         this.productRepository = productRepository;
         this.reviewFavoriteRepository = reviewFavoriteRepository;
         this.imageUploader = imageUploader;
+        this.sortingReviewService = sortingReviewService;
         this.eventPublisher = eventPublisher;
     }
 
@@ -121,8 +126,7 @@ public void likeReview(final Long reviewId, final Long memberId, final ReviewFav
 
     private ReviewFavorite saveReviewFavorite(final Member member, final Review review, final Boolean favorite) {
         try {
-            final ReviewFavorite reviewFavorite = ReviewFavorite.create(member, review,
-                    favorite);
+            final ReviewFavorite reviewFavorite = ReviewFavorite.create(member, review, favorite);
             return reviewFavoriteRepository.save(reviewFavorite);
         } catch (final DataIntegrityViolationException e) {
             throw new MemberDuplicateFavoriteException(MEMBER_DUPLICATE_FAVORITE, member.getId());
@@ -134,33 +138,44 @@ public void updateProductImage(final Long productId) {
         final Product product = productRepository.findById(productId)
                 .orElseThrow(() -> new ProductNotFoundException(PRODUCT_NOT_FOUND, productId));
 
-        final PageRequest pageRequest = PageRequest.of(TOP, ONE);
+        final PageRequest pageRequest = PageRequest.of(START, ONE);
+
         final List<Review> topFavoriteReview = reviewRepository.findPopularReviewWithImage(productId, pageRequest);
         if (!topFavoriteReview.isEmpty()) {
-            final String topFavoriteReviewImage = topFavoriteReview.get(TOP).getImage();
+            final String topFavoriteReviewImage = topFavoriteReview.get(START).getImage();
             product.updateImage(topFavoriteReviewImage);
         }
     }
 
-    public SortingReviewsResponse sortingReviews(final Long productId, final Pageable pageable, final Long memberId) {
-        final Member member = memberRepository.findById(memberId)
+    public SortingReviewsResponse sortingReviews(final Long productId, final Long memberId,
+                                                 final SortingReviewRequest request) {
+        final Member findMember = memberRepository.findById(memberId)
                 .orElseThrow(() -> new MemberNotFoundException(MEMBER_NOT_FOUND, memberId));
-
-        final Product product = productRepository.findById(productId)
+        final Product findProduct = productRepository.findById(productId)
                 .orElseThrow(() -> new ProductNotFoundException(PRODUCT_NOT_FOUND, productId));
 
-        final Page<Review> reviewPage = reviewRepository.findReviewsByProduct(pageable, product);
+        final List<SortingReviewDto> sortingReviews = sortingReviewService.getSortingReviews(findMember, findProduct, request);
+        final int resultSize = getResultSize(sortingReviews);
 
-        final PageDto pageDto = PageDto.toDto(reviewPage);
-        final List<SortingReviewDto> reviewDtos = reviewPage.stream()
-                .map(review -> SortingReviewDto.toDto(review, member))
-                .collect(Collectors.toList());
+        final List<SortingReviewDto> resizeSortingReviews = sortingReviews.subList(START, resultSize);
+        final Boolean hasNext = hasNextPage(sortingReviews);
+
+        return SortingReviewsResponse.toResponse(resizeSortingReviews, hasNext);
+    }
+
+    private int getResultSize(final List<SortingReviewDto> sortingReviews) {
+        if (sortingReviews.size() <= REVIEW_PAGE_SIZE) {
+            return sortingReviews.size();
+        }
+        return REVIEW_PAGE_SIZE;
+    }
 
-        return SortingReviewsResponse.toResponse(pageDto, reviewDtos);
+    private Boolean hasNextPage(final List<SortingReviewDto> sortingReviews) {
+        return sortingReviews.size() > REVIEW_PAGE_SIZE;
     }
 
     public RankingReviewsResponse getTopReviews() {
-        final List<Review> rankingReviews = reviewRepository.findTop3ByOrderByFavoriteCountDesc();
+        final List<Review> rankingReviews = reviewRepository.findTop3ByOrderByFavoriteCountDescIdDesc();
 
         final List<RankingReviewDto> dtos = rankingReviews.stream()
                 .map(RankingReviewDto::toDto)

backend/src/main/java/com/funeat/review/application/SortingReviewService.java

@@ -0,0 +1,66 @@
+package com.funeat.review.application;
+
+import static com.funeat.review.exception.ReviewErrorCode.REVIEW_NOT_FOUND;
+
+import com.funeat.member.domain.Member;
+import com.funeat.product.domain.Product;
+import com.funeat.review.domain.Review;
+import com.funeat.review.dto.SortingReviewDto;
+import com.funeat.review.dto.SortingReviewDtoWithoutTag;
+import com.funeat.review.dto.SortingReviewRequest;
+import com.funeat.review.exception.ReviewException.ReviewNotFoundException;
+import com.funeat.review.persistence.ReviewRepository;
+import com.funeat.review.specification.SortingReviewSpecification;
+import com.funeat.tag.persistence.TagRepository;
+import java.util.List;
+import java.util.stream.Collectors;
+import org.springframework.data.jpa.domain.Specification;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+@Service
+@Transactional(readOnly = true)
+public class SortingReviewService {
+
+    private static final int FIRST_PAGE = 0;
+
+    private final ReviewRepository reviewRepository;
+    private final TagRepository tagRepository;
+
+    public SortingReviewService(final ReviewRepository reviewRepository, final TagRepository tagRepository) {
+        this.reviewRepository = reviewRepository;
+        this.tagRepository = tagRepository;
+    }
+
+    public List<SortingReviewDto> getSortingReviews(final Member member, final Product product,
+                                                    final SortingReviewRequest request) {
+        final Long lastReviewId = request.getLastReviewId();
+        final String sortOption = request.getSort();
+
+        final Specification<Review> specification = getSortingSpecification(product, sortOption, lastReviewId);
+        final List<SortingReviewDtoWithoutTag> sortingReviewDtoWithoutTags = reviewRepository.getSortingReview(member,
+                specification, sortOption);
+
+        return addTagsToSortingReviews(sortingReviewDtoWithoutTags);
+    }
+
+    private List<SortingReviewDto> addTagsToSortingReviews(
+            final List<SortingReviewDtoWithoutTag> sortingReviewDtoWithoutTags) {
+        return sortingReviewDtoWithoutTags.stream()
+                .map(reviewDto -> SortingReviewDto.toDto(reviewDto,
+                        tagRepository.findTagsByReviewId(reviewDto.getId())))
+                .collect(Collectors.toList());
+    }
+
+    private Specification<Review> getSortingSpecification(final Product product, final String sortOption,
+                                                          final Long lastReviewId) {
+        if (lastReviewId == FIRST_PAGE) {
+            return SortingReviewSpecification.sortingFirstPageBy(product);
+        }
+
+        final Review lastReview = reviewRepository.findById(lastReviewId)
+                .orElseThrow(() -> new ReviewNotFoundException(REVIEW_NOT_FOUND, lastReviewId));
+
+        return SortingReviewSpecification.sortingBy(product, sortOption, lastReview);
+    }
+}

backend/src/main/java/com/funeat/review/dto/SortingReviewDto.java

@@ -1,12 +1,16 @@
 package com.funeat.review.dto;
 
+import com.fasterxml.jackson.annotation.JsonCreator;
 import com.funeat.member.domain.Member;
 import com.funeat.member.domain.favorite.ReviewFavorite;
 import com.funeat.review.domain.Review;
 import com.funeat.review.domain.ReviewTag;
+import com.funeat.tag.domain.Tag;
 import com.funeat.tag.dto.TagDto;
 import java.time.LocalDateTime;
+import java.util.Collections;
 import java.util.List;
+import java.util.Objects;
 import java.util.stream.Collectors;
 
 public class SortingReviewDto {
@@ -23,6 +27,7 @@ public class SortingReviewDto {
     private final boolean favorite;
     private final LocalDateTime createdAt;
 
+    @JsonCreator
     public SortingReviewDto(final Long id, final String userName, final String profileImage, final String image,
                             final Long rating, final List<TagDto> tags,
                             final String content, final boolean rebuy, final Long favoriteCount, final boolean favorite,
@@ -40,37 +45,23 @@ public SortingReviewDto(final Long id, final String userName, final String profi
         this.createdAt = createdAt;
     }
 
-    public static SortingReviewDto toDto(final Review review, final Member member) {
-        return new SortingReviewDto(
-                review.getId(),
-                review.getMember().getNickname(),
-                review.getMember().getProfileImage(),
-                review.getImage(),
-                review.getRating(),
-                findTagDtos(review),
-                review.getContent(),
-                review.getReBuy(),
-                review.getFavoriteCount(),
-                findReviewFavoriteChecked(review, member),
-                review.getCreatedAt()
-        );
-    }
-
-    private static List<TagDto> findTagDtos(final Review review) {
-        return review.getReviewTags().stream()
-                .map(ReviewTag::getTag)
+    public static SortingReviewDto toDto(final SortingReviewDtoWithoutTag sortingReviewDto, final List<Tag> tags) {
+        final List<TagDto> tagDtos = tags.stream()
                 .map(TagDto::toDto)
                 .collect(Collectors.toList());
-    }
 
-    private static boolean findReviewFavoriteChecked(final Review review, final Member member) {
-        return review.getReviewFavorites()
-                .stream()
-                .filter(reviewFavorite -> reviewFavorite.getReview().equals(review))
-                .filter(reviewFavorite -> reviewFavorite.getMember().equals(member))
-                .findFirst()
-                .map(ReviewFavorite::getFavorite)
-                .orElse(false);
+        return new SortingReviewDto(
+                sortingReviewDto.getId(),
+                sortingReviewDto.getUserName(),
+                sortingReviewDto.getProfileImage(),
+                sortingReviewDto.getImage(),
+                sortingReviewDto.getRating(),
+                tagDtos,
+                sortingReviewDto.getContent(),
+                sortingReviewDto.getRebuy(),
+                sortingReviewDto.getFavoriteCount(),
+                sortingReviewDto.getFavorite(),
+                sortingReviewDto.getCreatedAt());
     }
 
     public Long getId() {
@@ -101,15 +92,15 @@ public String getContent() {
         return content;
     }
 
-    public boolean isRebuy() {
+    public boolean getRebuy() {
         return rebuy;
     }
 
     public Long getFavoriteCount() {
         return favoriteCount;
     }
 
-    public boolean isFavorite() {
+    public boolean getFavorite() {
         return favorite;
     }
 

backend/src/main/java/com/funeat/review/dto/SortingReviewDtoWithoutTag.java

@@ -0,0 +1,84 @@
+package com.funeat.review.dto;
+
+import java.time.LocalDateTime;
+import java.util.Objects;
+
+public class SortingReviewDtoWithoutTag {
+
+    private final Long id;
+    private final String userName;
+    private final String profileImage;
+    private final String image;
+    private final Long rating;
+    private final String content;
+    private final boolean rebuy;
+    private final Long favoriteCount;
+    private final boolean favorite;
+    private final LocalDateTime createdAt;
+
+    public SortingReviewDtoWithoutTag(final Long id, final String userName, final String profileImage,
+                                      final String image, final Long rating,
+                                      final String content, final boolean rebuy, final Long favoriteCount,
+                                      final Boolean favorite,
+                                      final LocalDateTime createdAt) {
+        final Boolean isFavorite = checkingFavorite(favorite);
+
+        this.id = id;
+        this.userName = userName;
+        this.profileImage = profileImage;
+        this.image = image;
+        this.rating = rating;
+        this.content = content;
+        this.rebuy = rebuy;
+        this.favoriteCount = favoriteCount;
+        this.favorite = isFavorite;
+        this.createdAt = createdAt;
+    }
+
+    private static Boolean checkingFavorite(final Boolean favorite) {
+        if (Objects.isNull(favorite)) {
+            return Boolean.FALSE;
+        }
+        return Boolean.TRUE;
+    }
+
+    public Long getId() {
+        return id;
+    }
+
+    public String getUserName() {
+        return userName;
+    }
+
+    public String getProfileImage() {
+        return profileImage;
+    }
+
+    public String getImage() {
+        return image;
+    }
+
+    public Long getRating() {
+        return rating;
+    }
+
+    public String getContent() {
+        return content;
+    }
+
+    public boolean getRebuy() {
+        return rebuy;
+    }
+
+    public Long getFavoriteCount() {
+        return favoriteCount;
+    }
+
+    public boolean getFavorite() {
+        return favorite;
+    }
+
+    public LocalDateTime getCreatedAt() {
+        return createdAt;
+    }
+}

backend/src/main/java/com/funeat/review/dto/SortingReviewRequest.java

@@ -0,0 +1,27 @@
+package com.funeat.review.dto;
+
+import javax.validation.constraints.NotNull;
+import javax.validation.constraints.PositiveOrZero;
+
+public class SortingReviewRequest {
+
+    @NotNull(message = "정렬 조건을 확인해주세요")
+    private String sort;
+
+    @NotNull(message = "마지막으로 조회한 리뷰 ID를 확인해주세요")
+    @PositiveOrZero(message = "마지막으로 조회한 ID는 0 이상이어야 합니다. (처음 조회하면 0)")
+    private Long lastReviewId;
+
+    public SortingReviewRequest(final String sort, final Long lastReviewId) {
+        this.sort = sort;
+        this.lastReviewId = lastReviewId;
+    }
+
+    public String getSort() {
+        return sort;
+    }
+
+    public Long getLastReviewId() {
+        return lastReviewId;
+    }
+}