인기 댓글 조회 기능 구현

src/main/java/balancetalk/global/config/SecurityConfig.java

@@ -32,7 +32,7 @@ public class SecurityConfig {
             // swagger
             "/swagger-ui/**", "/v3/api-docs/**",
             "/members/duplicate",
-            "/posts", "/posts/{postId}", "/posts/{postId}/vote", "/posts/{postId}/comments",
+            "/posts", "/posts/{postId}", "/posts/{postId}/vote", "/posts/{postId}/comments/**",
             "/notices", "/notices/{noticeId}"
     };
 

src/main/java/balancetalk/module/comment/application/CommentService.java

@@ -2,6 +2,7 @@
 
 import balancetalk.global.exception.BalanceTalkException;
 import balancetalk.global.exception.ErrorCode;
+import balancetalk.global.utils.SecurityUtils;
 import balancetalk.module.comment.domain.Comment;
 import balancetalk.module.comment.domain.CommentLike;
 import balancetalk.module.comment.domain.CommentLikeRepository;
@@ -16,9 +17,12 @@
 import balancetalk.module.post.domain.PostRepository;
 import balancetalk.module.vote.domain.Vote;
 import balancetalk.module.vote.domain.VoteRepository;
+import java.util.ArrayList;
+import java.util.List;
 import lombok.RequiredArgsConstructor;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.data.domain.Page;
+import org.springframework.data.domain.PageRequest;
 import org.springframework.data.domain.Pageable;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
@@ -32,6 +36,9 @@
 @RequiredArgsConstructor
 public class CommentService {
 
+    private static final int BEST_COMMENTS_SIZE = 3;
+    private static final int MIN_COUNT_FOR_BEST_COMMENT = 15;
+
     private final CommentRepository commentRepository;
     private final MemberRepository memberRepository;
     private final PostRepository postRepository;
@@ -53,7 +60,7 @@ public Comment createComment(CommentRequest request, Long postId) {
     }
 
     @Transactional(readOnly = true)
-    public Page<CommentResponse> findAllComments(Long postId, Pageable pageable) {
+    public Page<CommentResponse> findAllComments(Long postId, String token, Pageable pageable) {
         validatePostId(postId);
 
         Page<Comment> comments = commentRepository.findAllByPostId(postId, pageable);
@@ -65,7 +72,12 @@ public Page<CommentResponse> findAllComments(Long postId, Pageable pageable) {
             Long balanceOptionId = voteForComment.map(Vote::getBalanceOption).map(BalanceOption::getId)
                     .orElseThrow(() -> new BalanceTalkException(NOT_FOUND_BALANCE_OPTION));
 
-            return CommentResponse.fromEntity(comment, balanceOptionId);
+            if (token == null) {
+                return CommentResponse.fromEntity(comment, balanceOptionId, false);
+            } else {
+                Member member = getCurrentMember(memberRepository);
+                return CommentResponse.fromEntity(comment, balanceOptionId, member.hasLikedComment(comment));
+            }
         });
     }
 
@@ -180,4 +192,32 @@ public void cancelLikeComment(Long commentId) {
 
         commentLikeRepository.deleteByMemberAndComment(member, comment);
     }
+
+    @Transactional(readOnly = true)
+    public List<CommentResponse> findBestComments(Long postId, String token) {
+        Post post = validatePostId(postId);
+        List<BalanceOption> options = post.getOptions();
+
+        List<CommentResponse> responses = new ArrayList<>();
+        for (BalanceOption option : options) {
+            List<Long> memberIdsBySelectedOptionId =
+                    memberRepository.findMemberIdsBySelectedOptionId(option.getId());
+
+            List<Comment> bestComments = commentRepository.findBestCommentsByPostId(postId,
+                    memberIdsBySelectedOptionId, 2, PageRequest.of(0, BEST_COMMENTS_SIZE));
+
+            if (token == null) {
+                responses.addAll(bestComments.stream()
+                        .map(comment -> CommentResponse.fromEntity(comment, option.getId(), false)).toList());
+            } else {
+                Member member = getCurrentMember(memberRepository);
+                responses.addAll(bestComments.stream()
+                        .map(comment ->
+                                CommentResponse.fromEntity(comment, option.getId(), member.hasLikedComment(comment)))
+                        .toList());
+            }
+        }
+
+        return responses;
+    }
 }

src/main/java/balancetalk/module/comment/domain/CommentLike.java

@@ -5,9 +5,11 @@
 import lombok.AccessLevel;
 import lombok.AllArgsConstructor;
 import lombok.Builder;
+import lombok.Getter;
 import lombok.NoArgsConstructor;
 
 @Entity
+@Getter
 @Builder
 @AllArgsConstructor(access = AccessLevel.PRIVATE)
 @NoArgsConstructor(access = AccessLevel.PROTECTED)

src/main/java/balancetalk/module/comment/domain/CommentRepository.java

@@ -1,9 +1,22 @@
 package balancetalk.module.comment.domain;
 
+import java.util.List;
 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;
 
 public interface CommentRepository extends JpaRepository<Comment, Long> {
     Page<Comment> findAllByPostId(Long postId, Pageable pageable);
+
+    @Query("select c from Comment c left join c.likes l "
+            + "where c.post.id = :postId and c.member.id in :memberIds "
+            + "group by c.id "
+            + "having count(l) >= :minCountForBest "
+            + "order by count(l) desc")
+    List<Comment> findBestCommentsByPostId(@Param("postId") Long postId,
+                                           @Param("memberIds") List<Long> memberIds,
+                                           @Param("minCountForBest") int minCountForBest,
+                                           Pageable pageable);
 }

src/main/java/balancetalk/module/comment/dto/CommentResponse.java

@@ -31,20 +31,24 @@ public class CommentResponse {
     @Schema(description = "댓글 추천 수", example = "24")
     private int likesCount;
 
+    @Schema(description = "추천 여부", example = "true")
+    private boolean myLike;
+
     @Schema(description = "댓글 생성 날짜")
     private LocalDateTime createdAt;
 
     @Schema(description = "댓글 수정 날짜")
     private LocalDateTime lastModifiedAt;
 
-    public static CommentResponse fromEntity(Comment comment, Long balanceOptionId) {
+    public static CommentResponse fromEntity(Comment comment, Long balanceOptionId, boolean myLike) {
         return CommentResponse.builder()
                 .id(comment.getId())
                 .content(comment.getContent())
                 .memberName(comment.getMember().getNickname())
                 .postId(comment.getPost().getId())
                 .selectedOptionId(balanceOptionId)
                 .likesCount(comment.getLikes().size())
+                .myLike(myLike)
                 .createdAt(comment.getCreatedAt())
                 .lastModifiedAt(comment.getLastModifiedAt())
                 .build();

src/main/java/balancetalk/module/comment/presentation/CommentController.java

@@ -6,6 +6,7 @@
 import balancetalk.module.comment.dto.ReplyCreateRequest;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.tags.Tag;
+import java.util.List;
 import lombok.RequiredArgsConstructor;
 import org.springframework.data.domain.Page;
 import org.springframework.data.domain.Pageable;
@@ -31,8 +32,17 @@ public String createComment(@PathVariable Long postId, @RequestBody CommentReque
     @ResponseStatus(HttpStatus.OK)
     @GetMapping
     @Operation(summary = "댓글 목록 조회", description = "post-id에 해당하는 게시글에 있는 모든 댓글을 조회한다.")
-    public Page<CommentResponse> findAllCommentsByPostId(@PathVariable Long postId, Pageable pageable) {
-        return commentService.findAllComments(postId, pageable);
+    public Page<CommentResponse> findAllCommentsByPostId(@PathVariable Long postId, Pageable pageable,
+                                                         @RequestHeader(value = "Authorization", required = false) String token) {
+        return commentService.findAllComments(postId, token, pageable);
+    }
+
+    @ResponseStatus(HttpStatus.OK)
+    @GetMapping("/best")
+    @Operation(summary = "인기 댓글 조회", description = "추천 수가 가장 많은 댓글을 각 선택지별로 3개씩 조회한다.")
+    public List<CommentResponse> findBestComments(@PathVariable Long postId,
+                                                  @RequestHeader(value = "Authorization", required = false) String token) {
+        return commentService.findBestComments(postId, token);
     }
 
     @ResponseStatus(HttpStatus.OK)

src/main/java/balancetalk/module/member/domain/Member.java

@@ -140,4 +140,9 @@ public boolean hasLiked(Post post) {
         return postLikes.stream()
                 .anyMatch(like -> like.getPost().equals(post));
     }
+
+    public boolean hasLikedComment(Comment comment) {
+        return commentLikes.stream()
+                .anyMatch(like -> like.getComment().equals(comment));
+    }
 }

src/main/java/balancetalk/module/member/domain/MemberRepository.java

@@ -1,10 +1,16 @@
 package balancetalk.module.member.domain;
 
+import java.util.List;
 import org.springframework.data.jpa.repository.JpaRepository;
 import java.util.Optional;
+import org.springframework.data.jpa.repository.Query;
+
 public interface MemberRepository extends JpaRepository<Member, Long> {
     Optional<Member> findByEmail(String username);
     boolean existsByNickname(String nickname);
     boolean existsByEmail(String email);
     void deleteByEmail(String email);
+
+    @Query("select m.id from Member m JOIN m.votes v WHERE v.balanceOption.id = :balanceOptionId")
+    List<Long> findMemberIdsBySelectedOptionId(Long balanceOptionId);
 }