[LNK-39] 피드 댓글 기능 구현

src/main/java/leets/leenk/domain/feed/application/dto/request/CommentWriteRequest.java

@@ -0,0 +1,9 @@
+package leets.leenk.domain.feed.application.dto.request;
+
+import jakarta.validation.constraints.NotBlank;
+
+public record CommentWriteRequest(
+        @NotBlank
+        String comment
+) {
+}

src/main/java/leets/leenk/domain/feed/application/dto/response/FeedCommentResponse.java

@@ -0,0 +1,27 @@
+package leets.leenk.domain.feed.application.dto.response;
+
+import com.fasterxml.jackson.annotation.JsonInclude;
+import com.fasterxml.jackson.annotation.JsonUnwrapped;
+import io.swagger.v3.oas.annotations.media.Schema;
+import leets.leenk.domain.user.application.dto.response.UserProfileResponse;
+import lombok.Builder;
+
+import java.time.LocalDateTime;
+
+@Builder
+@JsonInclude(JsonInclude.Include.NON_NULL)
+public record FeedCommentResponse(
+        @Schema(description = "댓글 id", example = "1")
+        long commentId,
+
+        @JsonUnwrapped
+        @Schema(implementation = UserProfileResponse.class)
+        UserProfileResponse user,
+
+        @Schema(description = "댓글", example = "오 좋은데??")
+        String comment,
+
+        @Schema(description = "댓글 작성 시간", example = "2025-06-30T00:00:00")
+        LocalDateTime createdAt
+) {
+}

src/main/java/leets/leenk/domain/feed/application/dto/response/FeedDetailResponse.java

@@ -33,6 +33,9 @@ public record FeedDetailResponse(
         long linkedUserCount,
 
         @Schema(description = "함께한 사용자 목록")
-        List<LinkedUserResponse> linkedUser
+        List<LinkedUserResponse> linkedUser,
+
+        @Schema(description = "피드에 작성된 댓글 목록")
+        List<FeedCommentResponse> comments
 ) {
 }

src/main/java/leets/leenk/domain/feed/application/exception/CommentDeleteNotAllowedException.java

@@ -0,0 +1,9 @@
+package leets.leenk.domain.feed.application.exception;
+
+import leets.leenk.global.common.exception.BaseException;
+
+public class CommentDeleteNotAllowedException extends BaseException {
+    public CommentDeleteNotAllowedException() {
+        super(ErrorCode.COMMENT_DELETE_NOT_ALLOWED);
+    }
+}

src/main/java/leets/leenk/domain/feed/application/exception/CommentNotFoundException.java

@@ -0,0 +1,9 @@
+package leets.leenk.domain.feed.application.exception;
+
+import leets.leenk.global.common.exception.BaseException;
+
+public class CommentNotFoundException extends BaseException {
+    public CommentNotFoundException() {
+        super(ErrorCode.COMMENT_NOT_FOUND);
+    }
+}

src/main/java/leets/leenk/domain/feed/application/exception/ErrorCode.java

@@ -13,7 +13,9 @@ public enum ErrorCode implements ErrorCodeInterface {
     FEED_NOT_FOUND(2200, HttpStatus.NOT_FOUND, "존재하지 않는 피드입니다."),
     SELF_REACTION(2202, HttpStatus.FORBIDDEN, "자신의 피드에 공감할 수 없습니다."),
     FEED_DELETE_NOT_ALLOWED(2203, HttpStatus.FORBIDDEN, "피드 삭제는 작성자만 가능합니다."),
-    FEED_UPDATE_NOT_ALLOWED(2204, HttpStatus.FORBIDDEN, "피드 수정은 작성자만 가능합니다.");
+    FEED_UPDATE_NOT_ALLOWED(2204, HttpStatus.FORBIDDEN, "피드 수정은 작성자만 가능합니다."),
+    COMMENT_NOT_FOUND(2205, HttpStatus.NOT_FOUND, "존재하지 않는 댓글입니다."),
+    COMMENT_DELETE_NOT_ALLOWED(2206, HttpStatus.FORBIDDEN, "댓글 삭제는 댓글 작성자만 가능합니다.");
 
     private final int code;
     private final HttpStatus status;

src/main/java/leets/leenk/domain/feed/application/mapper/CommentMapper.java

@@ -0,0 +1,18 @@
+package leets.leenk.domain.feed.application.mapper;
+
+import leets.leenk.domain.feed.application.dto.request.CommentWriteRequest;
+import leets.leenk.domain.feed.domain.entity.Comment;
+import leets.leenk.domain.feed.domain.entity.Feed;
+import leets.leenk.domain.user.domain.entity.User;
+import org.springframework.stereotype.Component;
+
+@Component
+public class CommentMapper {
+    public Comment toComment(User user, Feed feed, CommentWriteRequest request) {
+        return Comment.builder()
+                .user(user)
+                .feed(feed)
+                .comment(request.comment())
+                .build();
+    }
+}

src/main/java/leets/leenk/domain/feed/application/mapper/FeedMapper.java

@@ -1,6 +1,7 @@
 package leets.leenk.domain.feed.application.mapper;
 
 import leets.leenk.domain.feed.application.dto.response.*;
+import leets.leenk.domain.feed.domain.entity.Comment;
 import leets.leenk.domain.feed.domain.entity.Feed;
 import leets.leenk.domain.feed.domain.entity.LinkedUser;
 import leets.leenk.domain.media.application.dto.response.FeedMediaResponse;
@@ -76,7 +77,7 @@ public Feed toFeed(User user, String description) {
                 .build();
     }
 
-    public FeedDetailResponse toFeedDetailResponse(Feed feed, List<Media> medias, List<LinkedUser> linkedUsers) {
+    public FeedDetailResponse toFeedDetailResponse(Feed feed, List<Media> medias, List<LinkedUser> linkedUsers, List<Comment> comments) {
         return FeedDetailResponse.builder()
                 .feedId(feed.getId())
                 .author(toFeedAuthorResponse(feed))
@@ -86,6 +87,7 @@ public FeedDetailResponse toFeedDetailResponse(Feed feed, List<Media> medias, Li
                 .media(toFeedMediaResponses(medias))
                 .linkedUserCount(linkedUsers.size())
                 .linkedUser(toLinkedUserResponses(linkedUsers, feed))
+                .comments(toGetCommentsResponses(comments))
                 .build();
     }
 
@@ -110,34 +112,49 @@ private List<LinkedUserResponse> toLinkedUserResponses(List<LinkedUser> linkedUs
                 .toList();
     }
 
+    private List<FeedCommentResponse> toGetCommentsResponses(List<Comment> comments) {
+        return comments.stream()
+                .map(comment -> FeedCommentResponse.builder()
+                        .commentId(comment.getCommentId())
+                        .user(userProfileMapper.toProfile(comment.getUser()))
+                        .comment(comment.getComment())
+                        .createdAt(comment.getCreateDate())
+                        .build())
+                .toList();
+    }
+
     public FeedNavigationResponse toFeedNavigationResponse(
             Feed currentFeed,
             List<Feed> prevFeeds,
             List<Feed> nextFeeds,
             Map<Long, List<Media>> mediaMap,
             Map<Long, List<LinkedUser>> linkedUserMap,
+            Map<Long, List<Comment>> commentsMap,
             boolean hasMorePrev,
             boolean hasMoreNext
     ) {
         FeedDetailResponse current = toFeedDetailResponse(
                 currentFeed,
                 mediaMap.getOrDefault(currentFeed.getId(), List.of()),
-                linkedUserMap.getOrDefault(currentFeed.getId(), List.of())
+                linkedUserMap.getOrDefault(currentFeed.getId(), List.of()),
+                commentsMap.getOrDefault(currentFeed.getId(), List.of())
         );
 
         List<FeedDetailResponse> prevFeedResponses = prevFeeds.stream()
                 .map(feed -> toFeedDetailResponse(
                         feed,
                         mediaMap.getOrDefault(feed.getId(), List.of()),
-                        linkedUserMap.getOrDefault(feed.getId(), List.of())
+                        linkedUserMap.getOrDefault(feed.getId(), List.of()),
+                        commentsMap.getOrDefault(feed.getId(), List.of())
                 ))
                 .toList();
 
         List<FeedDetailResponse> nextFeedResponses = nextFeeds.stream()
                 .map(feed -> toFeedDetailResponse(
                         feed,
                         mediaMap.getOrDefault(feed.getId(), List.of()),
-                        linkedUserMap.getOrDefault(feed.getId(), List.of())
+                        linkedUserMap.getOrDefault(feed.getId(), List.of()),
+                        commentsMap.getOrDefault(feed.getId(), List.of())
                 ))
                 .toList();
 

src/main/java/leets/leenk/domain/feed/application/usecase/FeedUsecase.java

@@ -1,16 +1,16 @@
 package leets.leenk.domain.feed.application.usecase;
 
-import leets.leenk.domain.feed.application.dto.request.FeedReportRequest;
-import leets.leenk.domain.feed.application.dto.request.FeedUpdateRequest;
-import leets.leenk.domain.feed.application.dto.request.FeedUploadRequest;
-import leets.leenk.domain.feed.application.dto.request.ReactionRequest;
+import leets.leenk.domain.feed.application.dto.request.*;
 import leets.leenk.domain.feed.application.dto.response.*;
+import leets.leenk.domain.feed.application.exception.CommentDeleteNotAllowedException;
 import leets.leenk.domain.feed.application.exception.FeedDeleteNotAllowedException;
 import leets.leenk.domain.feed.application.exception.FeedUpdateNotAllowedException;
 import leets.leenk.domain.feed.application.exception.SelfReactionNotAllowedException;
+import leets.leenk.domain.feed.application.mapper.CommentMapper;
 import leets.leenk.domain.feed.application.mapper.FeedMapper;
 import leets.leenk.domain.feed.application.mapper.FeedUserMapper;
 import leets.leenk.domain.feed.application.mapper.ReactionMapper;
+import leets.leenk.domain.feed.domain.entity.Comment;
 import leets.leenk.domain.feed.domain.entity.Feed;
 import leets.leenk.domain.feed.domain.entity.LinkedUser;
 import leets.leenk.domain.feed.domain.entity.Reaction;
@@ -66,12 +66,17 @@ public class FeedUsecase {
     private final ReactionGetService reactionGetService;
     private final ReactionSaveService reactionSaveService;
 
+    private final CommentSaveService commentSaveService;
+    private final CommentGetService commentGetService;
+    private final CommentDeleteService commentDeleteService;
+
     private final FeedNotificationUsecase feedNotificationUsecase;
 
     private final FeedMapper feedMapper;
     private final MediaMapper mediaMapper;
     private final FeedUserMapper feedUserMapper;
     private final ReactionMapper reactionMapper;
+    private final CommentMapper commentMapper;
 
     @Transactional(readOnly = true)
     public FeedListResponse getFeeds(long userId, int pageNumber, int pageSize) {
@@ -95,8 +100,9 @@ public FeedDetailResponse getFeedDetail(Long feedId) {
         Feed feed = feedGetService.findById(feedId);
         List<Media> medias = mediaGetService.findAllByFeed(feed);
         List<LinkedUser> linkedUsers = linkedUserGetService.findAll(feed);
+        List<Comment> comments = commentGetService.findAllByFeed(feed);
 
-        return feedMapper.toFeedDetailResponse(feed, medias, linkedUsers);
+        return feedMapper.toFeedDetailResponse(feed, medias, linkedUsers, comments);
     }
 
     @Transactional(readOnly = true)
@@ -146,12 +152,19 @@ public FeedNavigationResponse getFeedNavigation(
             linkedUserMap.put(feed.getId(), linkedUsers);
         }
 
+        Map<Long, List<Comment>> commentsMap = new HashMap<>();
+        for (Feed feed : allFeeds) {
+            List<Comment> comments = commentGetService.findAllByFeed(feed);
+            commentsMap.put(feed.getId(), comments);
+        }
+
         return feedMapper.toFeedNavigationResponse(
                 currentFeed,
                 prevFeeds,
                 nextFeeds,
                 mediaMap,
                 linkedUserMap,
+                commentsMap,
                 hasMorePrev,
                 hasMoreNext
         );
@@ -219,6 +232,16 @@ public void reactToFeed(long userId, long feedId, ReactionRequest request) {
         notifyIfReachedReactionMilestone(previousReactionCount, updatedReactionCount, feed);
     }
 
+    @Transactional
+    public void writeComment(long userId, long feedId, CommentWriteRequest request) {
+        User user = userGetService.findById(userId);
+        Feed feed = feedGetService.findById(feedId);
+
+        Comment comment = commentMapper.toComment(user, feed, request);
+
+        commentSaveService.saveComment(comment);
+    }
+
     private void validateReaction(Feed feed, User user) {
         if (feed.getUser().equals(user)) {
             throw new SelfReactionNotAllowedException();
@@ -325,6 +348,18 @@ public void deleteFeed(long userId, long feedId) {
         feedDeleteService.delete(feed);
     }
 
+    @Transactional
+    public void deleteComment(long userId, long commentId) {
+        User user = userGetService.findById(userId);
+        Comment comment = commentGetService.findCommentByIdNotDeleted(commentId);
+
+        if (!comment.getUser().equals(user)) {
+            throw new CommentDeleteNotAllowedException();
+        }
+
+        commentDeleteService.deleteComment(comment);
+    }
+
     @Transactional(readOnly = true)
     public void reportFeed(long userId, long feedId, FeedReportRequest request) {
         User user = userGetService.findById(userId);

src/main/java/leets/leenk/domain/feed/domain/entity/Comment.java

@@ -0,0 +1,41 @@
+package leets.leenk.domain.feed.domain.entity;
+
+import jakarta.persistence.*;
+import leets.leenk.domain.user.domain.entity.User;
+import leets.leenk.global.common.entity.BaseEntity;
+import lombok.AccessLevel;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.experimental.SuperBuilder;
+
+import java.time.LocalDateTime;
+
+@Getter
+@Entity
+@SuperBuilder
+@Table(name = "comments")
+@NoArgsConstructor(access = AccessLevel.PROTECTED)
+public class Comment extends BaseEntity {
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    @Column(name = "comment_id")
+    private Long commentId;
+
+    @Column(name = "comments")
+    private String comment;
+
+    @ManyToOne(fetch = FetchType.LAZY, optional = false)
+    @JoinColumn(name = "feed_id", nullable = false, updatable = false)
+    private Feed feed;
+
+    @ManyToOne(fetch = FetchType.LAZY, optional = false)
+    @JoinColumn(name = "user_id", nullable = false, updatable = false)
+    private User user;
+
+    @Column(name = "deleted_at")
+    private LocalDateTime deletedAt;
+
+    public void deleteComment() {
+        this.deletedAt = LocalDateTime.now();
+    }
+}

src/main/java/leets/leenk/domain/feed/domain/repository/CommentRepository.java

@@ -0,0 +1,14 @@
+package leets.leenk.domain.feed.domain.repository;
+
+import leets.leenk.domain.feed.domain.entity.Comment;
+import leets.leenk.domain.feed.domain.entity.Feed;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+import java.util.List;
+import java.util.Optional;
+
+public interface CommentRepository extends JpaRepository<Comment, Long> {
+    Optional<Comment> findByCommentIdAndDeletedAtIsNull(long id);
+
+    List<Comment> findAllByFeedAndDeletedAtIsNullOrderByCreateDateDesc(Feed feed);
+}

src/main/java/leets/leenk/domain/feed/domain/service/CommentDeleteService.java

@@ -0,0 +1,15 @@
+package leets.leenk.domain.feed.domain.service;
+
+
+import leets.leenk.domain.feed.domain.entity.Comment;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+
+@Service
+@RequiredArgsConstructor
+public class CommentDeleteService {
+
+    public void deleteComment(Comment comment) {
+        comment.deleteComment();
+    }
+}

src/main/java/leets/leenk/domain/feed/domain/service/CommentGetService.java

@@ -0,0 +1,25 @@
+package leets.leenk.domain.feed.domain.service;
+
+import leets.leenk.domain.feed.application.exception.CommentNotFoundException;
+import leets.leenk.domain.feed.domain.entity.Comment;
+import leets.leenk.domain.feed.domain.entity.Feed;
+import leets.leenk.domain.feed.domain.repository.CommentRepository;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+
+@Service
+@RequiredArgsConstructor
+public class CommentGetService {
+    private final CommentRepository commentRepository;
+
+    public Comment findCommentByIdNotDeleted(long commentId) {
+        return commentRepository.findByCommentIdAndDeletedAtIsNull(commentId)
+                .orElseThrow(CommentNotFoundException::new);
+    }
+
+    public List<Comment> findAllByFeed(Feed feed) {
+        return commentRepository.findAllByFeedAndDeletedAtIsNullOrderByCreateDateDesc(feed);
+    }
+}

src/main/java/leets/leenk/domain/feed/domain/service/CommentSaveService.java

@@ -0,0 +1,16 @@
+package leets.leenk.domain.feed.domain.service;
+
+import leets.leenk.domain.feed.domain.entity.Comment;
+import leets.leenk.domain.feed.domain.repository.CommentRepository;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+
+@Service
+@RequiredArgsConstructor
+public class CommentSaveService {
+    private final CommentRepository commentRepository;
+
+    public void saveComment(Comment comment) {
+        commentRepository.save(comment);
+    }
+}