Ref: board 엔티티 개선

Author: joyewon0705

src/main/java/com/back/domain/board/comment/entity/Comment.java

@@ -9,63 +9,80 @@
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Objects;
 
 @Entity
 @Getter
 @NoArgsConstructor
 public class Comment extends BaseEntity {
     @ManyToOne(fetch = FetchType.LAZY)
-    @JoinColumn(name = "post_id")
+    @JoinColumn(name = "post_id", nullable = false)
     private Post post;
 
     @ManyToOne(fetch = FetchType.LAZY)
-    @JoinColumn(name = "user_id")
+    @JoinColumn(name = "user_id", nullable = false)
     private User user;
 
+    @Column(nullable = false, columnDefinition = "TEXT")
     private String content;
 
-    // TODO: 추후 CommentRepositoryImpl#getCommentsByPostId 로직 개선 필요, ERD에도 반영할 것
     @Column(nullable = false)
     private Long likeCount = 0L;
 
-    // 해당 댓글의 부모 댓글
     @ManyToOne(fetch = FetchType.LAZY)
     @JoinColumn(name = "parent_comment_id")
     private Comment parent;
 
-    // 해당 댓글에 달린 대댓글 목록
     @OneToMany(mappedBy = "parent", cascade = CascadeType.ALL, orphanRemoval = true)
     private List<Comment> children = new ArrayList<>();
 
     @OneToMany(mappedBy = "comment", cascade = CascadeType.ALL, orphanRemoval = true)
     private List<CommentLike> commentLikes = new ArrayList<>();
 
     // -------------------- 생성자 --------------------
-    public Comment(Post post, User user, String content) {
-        this.post = post;
-        this.user = user;
-        this.content = content;
-    }
-
     public Comment(Post post, User user, String content, Comment parent) {
         this.post = post;
         this.user = user;
         this.content = content;
         this.parent = parent;
+        post.addComment(this);
+        user.addComment(this);
+    }
+
+    // -------------------- 정적 팩토리 메서드 --------------------
+    /** 루트 댓글 생성 */
+    public static Comment createRoot(Post post, User user, String content) {
+        return new Comment(post, user, content, null);
+    }
+
+    /** 대댓글 생성 */
+    public static Comment createChild(Post post, User user, String content, Comment parent) {
+        Comment comment = new Comment(post, user, content, parent);
+        parent.getChildren().add(comment);
+        return comment;
+    }
+
+    // -------------------- 연관관계 편의 메서드 --------------------
+    public void addLike(CommentLike like) {
+        this.commentLikes.add(like);
+    }
+
+    public void removeLike(CommentLike like) {
+        this.commentLikes.remove(like);
     }
 
     // -------------------- 비즈니스 메서드 --------------------
-    // 댓글 업데이트
+    /** 댓글 내용 수정 */
     public void update(String content) {
         this.content = content;
     }
 
-    // 좋아요 수 증가
+    /** 좋아요 수 증가 */
     public void increaseLikeCount() {
         this.likeCount++;
     }
 
-    // 좋아요 수 감소
+    /** 좋아요 수 감소 */
     public void decreaseLikeCount() {
         if (this.likeCount > 0) {
             this.likeCount--;

src/main/java/com/back/domain/board/comment/entity/CommentLike.java

@@ -2,24 +2,31 @@
 
 import com.back.domain.user.entity.User;
 import com.back.global.entity.BaseEntity;
-import jakarta.persistence.Entity;
-import jakarta.persistence.FetchType;
-import jakarta.persistence.JoinColumn;
-import jakarta.persistence.ManyToOne;
+import jakarta.persistence.*;
 import lombok.AllArgsConstructor;
 import lombok.Getter;
 import lombok.NoArgsConstructor;
 
 @Entity
 @Getter
 @NoArgsConstructor
-@AllArgsConstructor
+@Table(
+        uniqueConstraints = @UniqueConstraint(columnNames = {"comment_id", "user_id"})
+)
 public class CommentLike extends BaseEntity {
     @ManyToOne(fetch = FetchType.LAZY)
-    @JoinColumn(name = "comment_id")
+    @JoinColumn(name = "comment_id", nullable = false)
     private Comment comment;
 
     @ManyToOne(fetch = FetchType.LAZY)
-    @JoinColumn(name = "user_id")
+    @JoinColumn(name = "user_id", nullable = false)
     private User user;
+
+    // -------------------- 생성자 --------------------
+    public CommentLike(Comment comment, User user) {
+        this.comment = comment;
+        this.user = user;
+        comment.addLike(this);
+        user.addCommentLike(this);
+    }
 }

src/main/java/com/back/domain/board/comment/repository/custom/CommentRepositoryImpl.java

@@ -4,6 +4,7 @@
 import com.back.domain.board.comment.dto.QCommentListResponse;
 import com.back.domain.board.comment.entity.Comment;
 import com.back.domain.board.comment.entity.QComment;
+import com.back.domain.board.comment.entity.QCommentLike;
 import com.back.domain.board.common.dto.QAuthorResponse;
 import com.back.domain.user.entity.QUser;
 import com.back.domain.user.entity.QUserProfile;
@@ -15,63 +16,71 @@
 import com.querydsl.jpa.impl.JPAQueryFactory;
 import lombok.RequiredArgsConstructor;
 import org.springframework.data.domain.*;
-
 import java.util.*;
 import java.util.stream.Collectors;
 
 @RequiredArgsConstructor
 public class CommentRepositoryImpl implements CommentRepositoryCustom {
     private final JPAQueryFactory queryFactory;
 
-    private static final Set<String> ALLOWED_SORT_FIELDS = Set.of("createdAt", "updatedAt", "likeCount");
-
+    // TODO: Comment에 likeCount 필드 추가에 따른 로직 개선
     /**
-     * 특정 게시글의 댓글 목록 조회
-     * - 총 쿼리 수: 3회
-     * 1.부모 댓글 목록을 페이징/정렬 조건으로 조회
-     * 2.부모 ID 목록으로 자식 댓글 전체 조회
-     * 3.부모 총 건수(count) 조회
+     * 게시글 ID로 댓글 목록 조회
+     * - 부모 댓글 페이징 + 자식 댓글 전체 조회
+     * - likeCount는 부모/자식 댓글을 한 번에 조회 후 주입
+     * - likeCount 정렬은 메모리에서 처리
+     * - 총 쿼리 수: 4회 (부모조회 + 자식조회 + likeCount + count)
      *
-     * @param postId   게시글 Id
+     * @param postId 게시글 Id
      * @param pageable 페이징 + 정렬 조건
      */
     @Override
     public Page<CommentListResponse> getCommentsByPostId(Long postId, Pageable pageable) {
         QComment comment = QComment.comment;
+        QCommentLike commentLike = QCommentLike.commentLike;
 
-        // 1. 정렬 조건 생성
-        List<OrderSpecifier<?>> orders = buildOrderSpecifiers(pageable);
+        // 1. 정렬 조건 생성 (엔티티 필드 기반)
+        List<OrderSpecifier<?>> orders = buildOrderSpecifiers(pageable, comment);
 
-        // 2. 부모 댓글 조회 (페이징 적용)
+        // 2. 부모 댓글 조회 (페이징)
         List<CommentListResponse> parents = fetchComments(
                 comment.post.id.eq(postId).and(comment.parent.isNull()),
                 orders,
                 pageable.getOffset(),
                 pageable.getPageSize()
         );
 
-        // 부모가 비어 있으면 즉시 빈 페이지 반환
         if (parents.isEmpty()) {
             return new PageImpl<>(parents, pageable, 0);
         }
 
-        // 3. 부모 ID 수집
+        // 3. 부모 ID 목록 수집
         List<Long> parentIds = parents.stream()
                 .map(CommentListResponse::getCommentId)
                 .toList();
 
-        // 4. 자식 댓글 조회 (부모 집합에 대한 전체 조회)
+        // 4. 자식 댓글 조회 (부모 ID 기준)
         List<CommentListResponse> children = fetchComments(
                 comment.parent.id.in(parentIds),
-                List.of(comment.createdAt.asc()),   // 시간순 정렬
+                List.of(comment.createdAt.asc()),
                 null,
                 null
         );
 
-        // 5. 부모-자식 매핑
+        // 5. 부모 + 자식 댓글 ID 합쳐 likeCount 조회 (쿼리 1회)
+        Map<Long, Long> likeCountMap = fetchLikeCounts(parentIds, children);
+
+        // 6. likeCount 주입
+        parents.forEach(p -> p.setLikeCount(likeCountMap.getOrDefault(p.getCommentId(), 0L)));
+        children.forEach(c -> c.setLikeCount(likeCountMap.getOrDefault(c.getCommentId(), 0L)));
+
+        // 7. 부모-자식 매핑
         mapChildrenToParents(parents, children);
 
-        // 6. 전체 부모 댓글 수 조회
+        // 8. 정렬 후처리 (통계 필드 기반)
+        parents = sortInMemoryIfNeeded(parents, pageable);
+
+        // 9. 전체 부모 댓글 수 조회
         Long total = queryFactory
                 .select(comment.count())
                 .from(comment)
@@ -86,11 +95,7 @@ public Page<CommentListResponse> getCommentsByPostId(Long postId, Pageable pagea
     /**
      * 댓글 조회
      * - User / UserProfile join (N+1 방지)
-     *
-     * @param condition where 조건
-     * @param orders    정렬 조건
-     * @param offset    페이징 offset (null이면 미적용)
-     * @param limit     페이징 limit  (null이면 미적용)
+     * - likeCount는 이후 주입
      */
     private List<CommentListResponse> fetchComments(
             BooleanExpression condition,
@@ -121,17 +126,42 @@ private List<CommentListResponse> fetchComments(
                 .where(condition)
                 .orderBy(orders.toArray(new OrderSpecifier[0]));
 
-        // 페이징 적용
         if (offset != null && limit != null) {
             query.offset(offset).limit(limit);
         }
 
         return query.fetch();
     }
 
+    /**
+     * likeCount 일괄 조회
+     * - IN 조건 기반 groupBy 쿼리 1회
+     * - 부모/자식 댓글을 한 번에 조회
+     */
+    private Map<Long, Long> fetchLikeCounts(List<Long> parentIds, List<CommentListResponse> children) {
+        QCommentLike commentLike = QCommentLike.commentLike;
+
+        List<Long> allIds = new ArrayList<>(parentIds);
+        allIds.addAll(children.stream().map(CommentListResponse::getCommentId).toList());
+
+        if (allIds.isEmpty()) return Map.of();
+
+        return queryFactory
+                .select(commentLike.comment.id, commentLike.count())
+                .from(commentLike)
+                .where(commentLike.comment.id.in(allIds))
+                .groupBy(commentLike.comment.id)
+                .fetch()
+                .stream()
+                .collect(Collectors.toMap(
+                        tuple -> tuple.get(commentLike.comment.id),
+                        tuple -> tuple.get(commentLike.count())
+                ));
+    }
+
     /**
      * 부모/자식 관계 매핑
-     * - 자식 목록을 parentId 기준으로 그룹화 후, 각 부모 DTO의 children에 설정
+     * - childMap을 parentId 기준으로 그룹화 후 children 필드에 set
      */
     private void mapChildrenToParents(List<CommentListResponse> parents, List<CommentListResponse> children) {
         if (children.isEmpty()) return;
@@ -140,37 +170,53 @@ private void mapChildrenToParents(List<CommentListResponse> parents, List<Commen
                 .collect(Collectors.groupingBy(CommentListResponse::getParentId));
 
         parents.forEach(parent ->
-                parent.setChildren(childMap.getOrDefault(parent.getCommentId(), Collections.emptyList()))
+                parent.setChildren(childMap.getOrDefault(parent.getCommentId(), List.of()))
         );
     }
 
     /**
-     * 정렬 조건 생성
-     * - Pageable의 Sort 정보를 QueryDSL OrderSpecifier 목록으로 변환
+     * 정렬 처리 (DB 정렬)
+     * - createdAt, updatedAt 등 엔티티 필드
      */
-    private List<OrderSpecifier<?>> buildOrderSpecifiers(Pageable pageable) {
-        QComment comment = QComment.comment;
+    private List<OrderSpecifier<?>> buildOrderSpecifiers(Pageable pageable, QComment comment) {
         PathBuilder<Comment> entityPath = new PathBuilder<>(Comment.class, comment.getMetadata());
         List<OrderSpecifier<?>> orders = new ArrayList<>();
 
         for (Sort.Order order : pageable.getSort()) {
-            String property = order.getProperty();
+            String prop = order.getProperty();
 
-            // 화이트리스트에 포함된 필드만 허용
-            if (!ALLOWED_SORT_FIELDS.contains(property)) {
-                // 허용되지 않은 정렬 키는 무시 (런타임 예외 대신 안전하게 스킵)
+            // 통계 필드는 메모리 정렬에서 처리
+            if (prop.equals("likeCount")) {
                 continue;
             }
-
             Order direction = order.isAscending() ? Order.ASC : Order.DESC;
-            orders.add(new OrderSpecifier<>(direction, entityPath.getComparable(property, Comparable.class)));
+            orders.add(new OrderSpecifier<>(direction, entityPath.getComparable(prop, Comparable.class)));
         }
 
-        // 명시된 정렬이 없으면 기본 정렬(createdAt DESC) 적용
-        if (orders.isEmpty()) {
-            orders.add(new OrderSpecifier<>(Order.DESC, comment.createdAt));
+        return orders;
+    }
+
+    /**
+     * 통계 기반 정렬 처리 (메모리)
+     * - likeCount 등 통계 필드
+     * - 페이지 단위라 성능에 영향 없음
+     */
+    private List<CommentListResponse> sortInMemoryIfNeeded(List<CommentListResponse> results, Pageable pageable) {
+        if (results.isEmpty() || !pageable.getSort().isSorted()) return results;
+
+        for (Sort.Order order : pageable.getSort()) {
+            Comparator<CommentListResponse> comparator = null;
+
+            if ("likeCount".equals(order.getProperty())) {
+                comparator = Comparator.comparing(CommentListResponse::getLikeCount);
+            }
+
+            if (comparator != null) {
+                if (order.isDescending()) comparator = comparator.reversed();
+                results.sort(comparator);
+            }
         }
 
-        return orders;
+        return results;
     }
-}
+}

src/main/java/com/back/domain/board/comment/service/CommentService.java

@@ -38,12 +38,15 @@ public class CommentService {
     private final PostRepository postRepository;
     private final ApplicationEventPublisher eventPublisher;
 
+    // TODO: 연관관계 고려, 메서드 명, 중복 코드 제거, 주석 통일
+    // TODO: comment 끝나면 post도 해야 함.. entity > DTO > Repo > Service > Controller > Docs 순으로..
     /**
      * 댓글 생성 서비스
      * 1. User 조회
      * 2. Post 조회
-     * 3. Comment 생성
-     * 4. Comment 저장 및 CommentResponse 반환
+     * 3. Comment 생성 및 저장
+     * 4. 댓글 작성 이벤트 발행
+     * 5. CommentResponse 반환
      */
     public CommentResponse createComment(Long postId, CommentRequest request, Long userId) {
         // User 조회
@@ -54,10 +57,11 @@ public CommentResponse createComment(Long postId, CommentRequest request, Long u
         Post post = postRepository.findById(postId)
                 .orElseThrow(() -> new CustomException(ErrorCode.POST_NOT_FOUND));
 
-        // Comment 생성
-        Comment comment = new Comment(post, user, request.content());
+        // CommentCount 증가
+        post.increaseCommentCount();
 
-        // Comment 저장 및 응답 반환
+        // Comment 생성 및 저장
+        Comment comment = Comment.createRoot(post, user, request.content());
         commentRepository.save(comment);
 
         // 댓글 작성 이벤트 발행