[프로젝트] 댓글과 대댓글 관계 로직 엔티티 하나로 구현하기 (JPA)

✅ Git Issue

https://github.com/ellaCoo/sns/issues/6

https://github.com/ellaCoo/sns/pull/31

📌 상황

→ Post에 해당하는 댓글에 대댓글까지 기능을 추가하기 위해 parent_comment_id 컬럼을 추가함

 

✔️ PostId로 [ 포스트정보 + 해당 포스트 댓글 + 유저의 좋아요 정보 ] 가져올 때, PostComment(댓글)과 대댓글을 createdAt(생성일시)로 정렬하여 함께 Response 객체에 담기

1. Post 엔티티 안에 Set<PostComment> postComments = new LinkedHashSet<>();를 정의하여 관계 맵핑

2. PostService 에서 postRepository.findById(postId) 로 Post 가져오기

3. PostWithLikesAndHashtagsAndCommentsDto 의 fromEntity 메서드로
Post 의 Set<PostComment> postComments = new LinkedHashSet<>();
⇒ PostWithLikesAndHashtagsAndCommentsDto 의 Set<PostCommentDto> postCommentDtos 로 변환

entity.getPostComments().stream()
                        .map(PostCommentDto::fromEntity)
                        .collect(Collectors.toCollection(LinkedHashSet::new))

⇒ 여기까지는 Post엔티티에 정의되어 있는 @OrderBy 내용인 생성일시 내림차순으로만 정렬되어 있다.

@OrderBy("createdAt DESC")
    @OneToMany(mappedBy = "post", cascade = CascadeType.ALL, fetch = FetchType.LAZY) // 연관된 엔티티도 모두 영속성 전이
    private Set<PostComment> postComments = new LinkedHashSet<>();

 

4. Dto를 PostWithLikesAndHashtagAndCommentsResponse 로 변환하는 과정에서
parentId를 활용하여 부모-자식 형태로 가공한다.

// PostWithLikesAndHashtagAndCommentsResponse

public static PostWithLikesAndHashtagAndCommentsResponse fromDto(PostWithLikesAndHashtagsAndCommentsDto dto, String userId) {
        Set<String> likes = dto.likeDtos().stream().map(likeDto -> likeDto.userId()).collect(Collectors.toSet());
        Set<String> hashtags = dto.hashtagDtos().stream().map(hashtagDto -> hashtagDto.hashtagName()).collect(Collectors.toSet());
        return new PostWithLikesAndHashtagAndCommentsResponse(
                PostResponse.fromDto(dto.postDto()),
                dto.userAccountDto().userId(),
                null != userId && likes.contains(userId),
                likes,
                organizeChildComments(dto.postCommentDtos()), // ⭐️⭐️⭐️⭐️⭐️
                hashtags
        );
    }
    
private static Set<PostCommentResponse> **organizeChildComments**(Set<PostCommentDto> dtos) {
				// Post의 댓글들을 {commentId : PostCommentResponse} 형태로 변환한다.  
        Map<Long, PostCommentResponse> map = dtos.stream()
                .map(PostCommentResponse::fromDto)
                .collect(Collectors.toMap(PostCommentResponse::id, Function.identity()));

        map.values().stream()
                .filter(comment -> comment.parentCommentId() != null) // 자식댓글인 애들 뽑아내기  
                .forEach(comment -> {
                    PostCommentResponse parentComment = map.get(comment.parentCommentId());
                    parentComment.childComments().add(comment); // 자식댓글의 부모댓글에 해당 자식댓글 추가   
                });

        return map.values().stream()
                .filter(comment -> comment.parentCommentId() == null) // 부모댓글인 애들만 뽑아내기 (위에서 자식댓글 추가 완료)      
                .collect(Collectors.toCollection(() ->
                        new TreeSet<>(Comparator
                                .comparing(PostCommentResponse::createdAt)
                                .reversed()
                                .thenComparingLong(PostCommentResponse::id)
                        )
                ));
    }

    //PostCommentResponse
public record PostCommentResponse(
        Long id,
        String content,
        LocalDateTime createdAt,
        String email,
        String nickname,
        String userId,
        Long parentCommentId,
        Set<PostCommentResponse> childComments
) {    
    
    public static PostCommentResponse of(Long id, String content, LocalDateTime createdAt, String email, String nickname, String userId, Long parentCommentId) {
        Comparator<PostCommentResponse> childCommentComparator = Comparator
                .comparing(PostCommentResponse::createdAt); // 생성시간 오름차순
                
        return new PostCommentResponse(id, content, createdAt, email, nickname, userId, parentCommentId, new TreeSet<>(childCommentComparator));
    }

 

🆘 구현을 하고 대댓글 기능 테스트를 진행하는데, 동일한 포스트에 동일한 parentId을 가진 대댓글이 2개가 나와야 하는데 하나만 나오는 댓글 누락현상을 발견함

원인

만약 createdAt만을 기준으로 정렬하고, 동일한 createdAt 값을 가진 여러 댓글이 존재한다면, 이들 간에 비교할 수 있는 추가적인 기준(ID 등)이 없기 때문에, 동일한 createdAt을 가진 댓글들 중 오직 하나의 댓글만 TreeSet에 저장됨

TreeSet은 요소를 저장할 때 정렬 기준이 동일한 객체를 중복으로 간주하고, 중복된 객체는 저장하지 않음.

⇒ Comparator<PostCommentResponse> childCommentComparator 에서
     생성시간 동일할 때 정렬기준을 id로 설정하여 댓글 누락을 피하자!

    //PostCommentResponse
    
    public static PostCommentResponse of(Long id, String content, LocalDateTime createdAt, String email, String nickname, String userId, Long parentCommentId) {
        Comparator<PostCommentResponse> childCommentComparator = Comparator
                .comparing(PostCommentResponse::createdAt) // 생성시간 오름차순
                .thenComparingLong(PostCommentResponse::id); // 생성시간 동일할때 정렬 기준
        return new PostCommentResponse(id, content, createdAt, email, nickname, userId, parentCommentId, new TreeSet<>(childCommentComparator));
    }

 

TreeSet & Comparator 란

TreeSet

- 특징
중복 허용 X: 동일한 값을 가지는 두 개의 요소를 허용하지 않음
자동 정렬: 삽입 순서에 관계없이 요소들이 자동으로 정렬됨

- 장점
정렬된 결과: 항상 정렬된 상태로 데이터를 유지하므로, 탐색이 쉽고 빠름
중복된 값 제거: 중복된 값을 자동으로 걸러내기 때문에 유용함

- 단점
삽입 속도: HashSet처럼 O(1)이 아니라, 트리 구조를 유지하는 데 O(log n)의 시간이 소요됨
메모리: 트리 구조를 유지해야 하므로, HashSet보다 더 많은 메모리를 사용할 수 있음

Comparator

Comparator는 객체를 비교하고 정렬 순서를 정의하는 인터페이스

 

전체 소스코드

👾PostController

PostWithLikesAndHashtagAndCommentsResponse response = PostWithLikesAndHashtagAndCommentsResponse
                .fromDto(postService.getPostWithLikesAndHashtagsAndComments(postId), user);

👾PostService

@Transactional(readOnly = true)
    public PostWithLikesAndHashtagsAndCommentsDto getPostWithLikesAndHashtagsAndComments(Long postId) {
        return postRepository.findById(postId)
                .map(PostWithLikesAndHashtagsAndCommentsDto::fromEntity)
                .orElseThrow(() -> new EntityNotFoundException("포스트가 없습니다 - postId: " + postId));
    }

👾PostWithLikesAndHashtagsAndCommentsDto

import java.util.LinkedHashSet;
import java.util.Set;
import java.util.stream.Collectors;

public record PostWithLikesAndHashtagsAndCommentsDto(
        PostDto postDto,
        UserAccountDto userAccountDto,
        Set<LikeDto> likeDtos,
        Set<PostCommentDto> postCommentDtos,
        Set<HashtagDto> hashtagDtos
) {
    public static PostWithLikesAndHashtagsAndCommentsDto of(PostDto postDto, UserAccountDto userAccountDto, Set<LikeDto> likeDtos, Set<PostCommentDto> postCommentDtos, Set<HashtagDto> hashtagDtos) {
        return new PostWithLikesAndHashtagsAndCommentsDto(postDto, userAccountDto, likeDtos, postCommentDtos, hashtagDtos);
    }

    public static PostWithLikesAndHashtagsAndCommentsDto fromEntity(Post entity) {
        return new PostWithLikesAndHashtagsAndCommentsDto(
                PostDto.fromEntity(entity),
                UserAccountDto.fromEntity(entity.getUserAccount()),
                entity.getLikes().stream()
                        .map(LikeDto::fromEntity)
                        .collect(Collectors.toCollection(LinkedHashSet::new))
                ,
                entity.getPostComments().stream()
                        .map(PostCommentDto::fromEntity)
                        .collect(Collectors.toCollection(LinkedHashSet::new))
                ,
                entity.getPostHashtags().stream()
                        .map(postHashtag -> postHashtag.getHashtag())
                        .map(HashtagDto::fromEntity)
                        .collect(Collectors.toSet())
        );
    }
}

👾Post

import jakarta.persistence.*;
import lombok.Getter;
import lombok.Setter;
import lombok.ToString;

import java.util.*;

@Getter
@Entity
public class Post extends AuditingFields {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Setter
    @JoinColumn(name = "userId")
    @ManyToOne(optional = false, fetch = FetchType.LAZY)
    private UserAccount userAccount;

    @Setter
    @Column(nullable = false)
    private String title;

    @Setter
    @Column(nullable = false, length = 10000)
    private String content;

    @OrderBy("createdAt DESC")
    @OneToMany(mappedBy = "post", cascade = CascadeType.ALL, fetch = FetchType.LAZY) // 연관된 엔티티도 모두 영속성 전이
    private Set<PostComment> postComments = new LinkedHashSet<>();

    @OneToMany(mappedBy = "post", cascade = CascadeType.ALL, fetch = FetchType.LAZY)
    private Set<Like> likes = new LinkedHashSet<>();

    @OneToMany(mappedBy = "post", cascade = CascadeType.ALL, fetch = FetchType.LAZY)
    private Set<PostHashtag> postHashtags = new LinkedHashSet<>();

    protected Post() {}

    private Post(UserAccount userAccount, String title, String content) {
        this.userAccount = userAccount;
        this.title = title;
        this.content = content;
    }

    public static Post of(UserAccount userAccount, String title, String content) {
        return new Post(userAccount, title, content);
    }
    
    @Override
    public boolean equals(Object o) {
        // 객체 동등성을 비교하는 메서드, 'id' 필드 기준으로 비교
        if (this == o) return true;
        if (!(o instanceof Post that)) return false;
        return this.getId() != null && this.getId().equals(that.getId());
    }

    @Override
    public int hashCode() {
        return Objects.hash(this.getId());
    }
}

👾PostCommentDto

import com.project.sns.domain.Post;
import com.project.sns.domain.PostComment;
import com.project.sns.domain.UserAccount;

import java.time.LocalDateTime;

public record PostCommentDto(
        Long id,
        Long postId,
        UserAccountDto userAccountDto,
        Long parentCommentId,
        String content,
        LocalDateTime createdAt,
        String createdBy,
        LocalDateTime modifiedAt,
        String modifiedBy
) {
    public static PostCommentDto of(Long postId, UserAccountDto userAccountDto, String content) {
        return PostCommentDto.of(postId, userAccountDto, null, content);
    }

    public static PostCommentDto of(Long postId, UserAccountDto userAccountDto, Long parentCommentId, String content) {
        return PostCommentDto.of(postId, userAccountDto, parentCommentId, content, null, null, null, null);
    }

    public static PostCommentDto of(Long postId, UserAccountDto userAccountDto, Long parentCommentId, String content, LocalDateTime createdAt, String createdBy, LocalDateTime modifiedAt, String modifiedBy) {
        return PostCommentDto.of(null, postId, userAccountDto, parentCommentId, content, createdAt, createdBy, modifiedAt, modifiedBy);
    }

    public static PostCommentDto of(Long id, Long postId, UserAccountDto userAccountDto, Long parentCommentId, String content, LocalDateTime createdAt, String createdBy, LocalDateTime modifiedAt, String modifiedBy) {
        return new PostCommentDto(id, postId, userAccountDto, parentCommentId, content, createdAt, createdBy, modifiedAt, modifiedBy);
    }

    public static PostCommentDto fromEntity(PostComment entity) {
        return new PostCommentDto(
                entity.getId(),
                entity.getPost().getId(),
                UserAccountDto.fromEntity(entity.getUserAccount()),
                entity.getParentCommentId(),
                entity.getContent(),
                entity.getCreatedAt(),
                entity.getCreatedBy(),
                entity.getModifiedAt(),
                entity.getModifiedBy()
        );
    }

    public PostComment toEntity(Post post, UserAccount userAccount) {
        return PostComment.of(
                post,
                userAccount,
                content
        );
    }
}

👾PostWithLikesAndHashtagAndCommentsResponse

import com.project.sns.dto.PostCommentDto;
import com.project.sns.dto.PostWithLikesAndHashtagsAndCommentsDto;

import java.util.Comparator;
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;
import java.util.function.Function;
import java.util.stream.Collectors;

public record PostWithLikesAndHashtagAndCommentsResponse(
        PostResponse postResponse,
        String userId,
        boolean isLike,
        Set<String> likeUserId,
        Set<PostCommentResponse> postCommentResponse,
        Set<String> hashtags
) {
    public static PostWithLikesAndHashtagAndCommentsResponse of(PostResponse postResponse, String userId, boolean isLike, Set<String> likeUserId, Set<PostCommentResponse> postCommentResponses, Set<String> hashtags) {
        return new PostWithLikesAndHashtagAndCommentsResponse(postResponse, userId, isLike, likeUserId, postCommentResponses, hashtags);
    }

    public static PostWithLikesAndHashtagAndCommentsResponse fromDto(PostWithLikesAndHashtagsAndCommentsDto dto, String userId) {
        Set<String> likes = dto.likeDtos().stream().map(likeDto -> likeDto.userId()).collect(Collectors.toSet());
        Set<String> hashtags = dto.hashtagDtos().stream().map(hashtagDto -> hashtagDto.hashtagName()).collect(Collectors.toSet());
        return new PostWithLikesAndHashtagAndCommentsResponse(
                PostResponse.fromDto(dto.postDto()),
                dto.userAccountDto().userId(),
                null != userId && likes.contains(userId),
                likes,
                **organizeChildComments(dto.postCommentDtos()), // ⭐️⭐️⭐️⭐️⭐️**
                hashtags
        );
    }

**// ⭐️⭐️⭐️⭐️⭐️**
    private static Set<PostCommentResponse> organizeChildComments(Set<PostCommentDto> dtos) {
        Map<Long, PostCommentResponse> map = dtos.stream()
                .map(PostCommentResponse::fromDto)
                .collect(Collectors.toMap(PostCommentResponse::id, Function.identity()));

        map.values().stream()
                .filter(comment -> comment.parentCommentId() != null)
                .forEach(comment -> {
                    PostCommentResponse parentComment = map.get(comment.parentCommentId());
                    parentComment.childComments().add(comment);
                });

        return map.values().stream()
                .filter(comment -> comment.parentCommentId() == null)
                .collect(Collectors.toCollection(() ->
                        new TreeSet<>(Comparator
                                .comparing(PostCommentResponse::createdAt)
                                .reversed()
                                .thenComparingLong(PostCommentResponse::id)
                        )
                ));
    }
}

👾PostCommentResponse

import com.project.sns.dto.PostCommentDto;

import java.time.LocalDateTime;
import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;

public record PostCommentResponse(
        Long id,
        String content,
        LocalDateTime createdAt,
        String email,
        String nickname,
        String userId,
        Long parentCommentId,
        Set<PostCommentResponse> childComments
) {
    // of: 정적 팩토리 메서드, 객체 생성과 초기화를 동시에 처리하여 새로운 PostCommentResponse 객체를 반환
    public static PostCommentResponse of(Long id, String content, LocalDateTime createdAt, String email, String nickname, String userId) {
        return PostCommentResponse.of(id, content, createdAt, email, nickname, userId, null);
    }

    public static PostCommentResponse of(Long id, String content, LocalDateTime createdAt, String email, String nickname, String userId, Long parentCommentId) {
        Comparator<PostCommentResponse> childCommentComparator = Comparator
                .comparing(PostCommentResponse::createdAt) // 생성시간 오름차순
                .thenComparingLong(PostCommentResponse::id); // 생성시간 동일할때 정렬 기준
        return new PostCommentResponse(id, content, createdAt, email, nickname, userId, parentCommentId, new TreeSet<>(childCommentComparator));
    }

    public static PostCommentResponse fromDto(PostCommentDto dto) {
        return PostCommentResponse.of(
                dto.id(), // 댓글 ID
                dto.content(),
                dto.createdAt(),
                dto.userAccountDto().email(),
                dto.userAccountDto().nickname(),
                dto.userAccountDto().userId(),
                dto.parentCommentId()
        );
    }
}