[FEAT]: 게시글 좋아요, 댓글 CRUD 구현

back/src/main/java/com/back/domain/comment/controller/CommentController.java

@@ -1,18 +1,90 @@
 package com.back.domain.comment.controller;
 
+import com.back.domain.comment.dto.CommentRequest;
+import com.back.domain.comment.dto.CommentResponse;
+import com.back.domain.comment.enums.CommentSortType;
 import com.back.domain.comment.service.CommentService;
+import com.back.global.common.PageResponse;
+import com.back.global.security.CustomUserDetails;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.Parameter;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import jakarta.validation.Valid;
 import lombok.RequiredArgsConstructor;
-import org.springframework.web.bind.annotation.RequestMapping;
-import org.springframework.web.bind.annotation.RestController;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.domain.Sort;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.security.core.annotation.AuthenticationPrincipal;
+import org.springframework.web.bind.annotation.*;
 
-/**
- * 댓글 관련 API 요청을 처리하는 컨트롤러.
- */
+@Tag(name = "Comment", description = "댓글 관련 API")
 @RestController
 @RequestMapping("/api/v1/posts/{postId}/comments")
 @RequiredArgsConstructor
 public class CommentController {
 
     private final CommentService commentService;
 
+    // 댓글 생성
+    @PostMapping
+    @Operation(summary = "댓글 생성", description = "새 댓글을 생성합니다.")
+    public ResponseEntity<CommentResponse> createPost(
+            @io.swagger.v3.oas.annotations.parameters.RequestBody(
+                    description = "생성할 댓글 정보",
+                    required = true
+            )
+            @RequestBody @Valid CommentRequest request,
+            @Parameter(description = "조회할 게시글 ID", required = true) @PathVariable("postId") Long postId,
+            @AuthenticationPrincipal CustomUserDetails cs
+    ) {
+        CommentResponse response = commentService.createComment(cs.getUser().getId(), postId, request);
+        return ResponseEntity.status(HttpStatus.CREATED).body(response);
+    }
+
+    // fixme 게시글 목록 조회 - 정렬 조건 최신순, 좋아요순 추가하였는데 변경될 수 있음
+    @GetMapping
+    @Operation(summary = "댓글 목록 조회", description = "게시글 목록을 조회합니다.")
+    public ResponseEntity<PageResponse<CommentResponse>> getPosts(
+            @Parameter(description = "페이지 정보") Pageable pageable,
+            @Parameter(description = "조회할 게시글 ID", required = true) @PathVariable("postId") Long postId,
+            @Parameter(description = "정렬 조건 LATEST or LIKES") @RequestParam(defaultValue = "LATEST") CommentSortType sortType,
+            @AuthenticationPrincipal CustomUserDetails cs) {
+
+        Sort sort = Sort.by(Sort.Direction.DESC, sortType.getProperty());
+
+        Pageable sortedPageable = PageRequest.of(
+                pageable.getPageNumber(),
+                pageable.getPageSize(),
+                sort
+        );
+
+        Page<CommentResponse> responses = commentService.getComments(cs.getUser().getId(), postId, sortedPageable);
+        return ResponseEntity.ok(PageResponse.of(responses));
+    }
+
+
+    @PutMapping("/{commentId}")
+    @Operation(summary = "댓글 수정", description = "자신의 댓글을 수정합니다.")
+    public ResponseEntity<Long> updateComment(
+            @Parameter(description = "수정할 댓글 ID", required = true) @PathVariable Long commentId,
+            @io.swagger.v3.oas.annotations.parameters.RequestBody(
+                    description = "수정할 댓글 정보",
+                    required = true
+            )
+            @RequestBody @Valid CommentRequest request,
+            @AuthenticationPrincipal CustomUserDetails cs) {
+        return ResponseEntity.ok(commentService.updateComment(cs.getUser().getId(), commentId, request));
+    }
+
+    @DeleteMapping("/{commentId}")
+    @Operation(summary = "댓글 삭제", description = "자신의 댓글을 삭제합니다.")
+    public ResponseEntity<Void> deletePost(
+            @Parameter(description = "삭제할 댓글 ID", required = true) @PathVariable Long commentId,
+            @AuthenticationPrincipal CustomUserDetails cs) {
+        commentService.deleteComment(cs.getUser().getId(), commentId);
+        return ResponseEntity.ok(null);
+    }
 }

back/src/main/java/com/back/domain/comment/dto/CommentRequest.java

@@ -0,0 +1,9 @@
+package com.back.domain.comment.dto;
+
+import jakarta.validation.constraints.NotBlank;
+
+public record CommentRequest(
+        @NotBlank(message = "내용은 필수입니다")
+        String content,
+        Boolean hide) {
+}

back/src/main/java/com/back/domain/comment/dto/CommentResponse.java

@@ -0,0 +1,31 @@
+package com.back.domain.comment.dto;
+
+import com.back.global.common.DateFormat;
+import io.swagger.v3.oas.annotations.media.Schema;
+
+import java.time.LocalDateTime;
+
+@Schema(description = "댓글 DTO")
+public record CommentResponse(
+        @Schema(description = "댓글 ID", example = "1")
+        Long commentId,
+
+        @Schema(description = "댓글 작성자 닉네임 또는 익명", example = "홍길동")
+        String author,
+
+        @Schema(description = "댓글 내용", example = "좋은 글이네요!")
+        String content,
+
+        @Schema(description = "댓글 좋아요 수", example = "10")
+        int likeCount,
+
+        @Schema(description = "사용자가 해당 댓글의 작성자인지 여부", example = "true")
+        boolean isMine,
+
+        @Schema(description = "사용자가 해당 댓글에 좋아요를 눌렀는지 여부", example = "true")
+        boolean isLiked,
+
+        @Schema(description = "댓글 작성일자", example = "2025.09.23")
+        @DateFormat
+        LocalDateTime createdDate
+) {}

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

@@ -3,12 +3,10 @@
 import com.back.domain.post.entity.Post;
 import com.back.domain.user.entity.User;
 import com.back.global.baseentity.BaseEntity;
+import com.back.global.exception.ApiException;
+import com.back.global.exception.ErrorCode;
 import jakarta.persistence.*;
-import lombok.AllArgsConstructor;
-import lombok.Builder;
-import lombok.Getter;
-import lombok.NoArgsConstructor;
-import lombok.Setter;
+import lombok.*;
 import org.hibernate.annotations.ColumnDefault;
 import org.springframework.data.annotation.LastModifiedDate;
 
@@ -24,9 +22,8 @@
 @Entity
 @Table(name = "comments")
 @Getter
-@Setter
-@NoArgsConstructor
-@AllArgsConstructor
+@NoArgsConstructor(access = AccessLevel.PROTECTED)
+@AllArgsConstructor(access = AccessLevel.PROTECTED)
 @Builder
 public class Comment extends BaseEntity {
 
@@ -56,4 +53,13 @@ public class Comment extends BaseEntity {
 
     @LastModifiedDate
     private LocalDateTime updatedAt;
+
+    public void checkUser(Long userId) {
+        if (!user.getId().equals(userId))
+            throw new ApiException(ErrorCode.UNAUTHORIZED_USER);
+    }
+
+    public void updateContent(String content) {
+        this.content = content;
+    }
 }

back/src/main/java/com/back/domain/comment/enums/CommentSortType.java

@@ -0,0 +1,18 @@
+package com.back.domain.comment.enums;
+
+import lombok.Getter;
+
+/**
+ * 최신순, 좋아요순
+ */
+@Getter
+public enum CommentSortType {
+    LATEST("createdDate"),
+    LIKES("likeCount");
+
+    private final String property;
+
+    CommentSortType(String property) {
+        this.property = property;
+    }
+}

back/src/main/java/com/back/domain/comment/mapper/CommentMappers.java

@@ -0,0 +1,65 @@
+package com.back.domain.comment.mapper;
+
+import com.back.domain.comment.dto.CommentRequest;
+import com.back.domain.comment.dto.CommentResponse;
+import com.back.domain.comment.entity.Comment;
+import com.back.domain.post.entity.Post;
+import com.back.domain.user.entity.User;
+import com.back.global.mapper.Mapper;
+import com.back.global.mapper.MappingException;
+import com.back.global.mapper.TwoWayMapper;
+
+
+/**
+ * CommentMappers
+ * 댓글(Comment) 관련 엔티티 ↔ DTO 매핑 유틸리티 클래스.
+ * 구성:
+ * - COMMENT_READ : Comment → CommentResponse 변환 (읽기 전역 매퍼)
+ * - CommentCtxMapper : CommentRequest ↔ Comment ↔ CommentResponse 변환 (쓰기 매퍼, 컨텍스트 보유)
+ *     - 사용자(User), 게시글(Post) 컨텍스트를 보유하여 엔티티 생성 시 활용
+ *     - 내가 쓴 댓글 여부, 좋아요 여부 등은 추후 구현 예정
+ */
+public final class CommentMappers {
+
+    private CommentMappers() {}
+
+    public static final Mapper<Comment, CommentResponse> COMMENT_READ = e -> {
+        if (e == null) throw new MappingException("Comment is null");
+        return new CommentResponse(
+                e.getId(),
+                e.isHide() ? "익명" : (e.getUser() != null ? e.getUser().getNickname() : null),
+                e.getContent(),
+                e.getLikeCount(),
+                false, // todo : 내가 쓴 댓글 여부 추후 구현
+                false, // todo : 좋아요 여부 추후 구현
+                e.getCreatedDate()
+        );
+    };
+
+    public static final class CommentCtxMapper implements TwoWayMapper<CommentRequest, Comment, CommentResponse> {
+        private final User user;
+        private final Post post;
+
+        public CommentCtxMapper(User user, Post post) {
+            this.user = user;
+            this.post = post;
+        }
+
+        @Override
+        public Comment toEntity(CommentRequest req) {
+            if (req == null) throw new MappingException("CommentRequest is null");
+            return Comment.builder()
+                    .user(user)
+                    .post(post)
+                    .content(req.content())
+                    .hide(req.hide() != null ? req.hide() : false)
+                    .build();
+        }
+
+        @Override
+        public CommentResponse toResponse(Comment entity) {
+            return COMMENT_READ.map(entity);
+        }
+    }
+}
+

back/src/main/java/com/back/domain/comment/repository/CommentRepository.java

@@ -1,12 +1,18 @@
 package com.back.domain.comment.repository;
 
 import com.back.domain.comment.entity.Comment;
+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;
 import org.springframework.stereotype.Repository;
 
 /**
  * 댓글 엔티티에 대한 데이터베이스 접근을 담당하는 JpaRepository.
  */
 @Repository
 public interface CommentRepository extends JpaRepository<Comment, Long> {
+    @Query("SELECT c FROM Comment c WHERE c.post.id = :postId")
+    Page<Comment> findCommentsByPostId(@Param("postId") Long postId, Pageable pageable);
 }

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

@@ -1,16 +1,69 @@
 package com.back.domain.comment.service;
 
+import com.back.domain.comment.dto.CommentRequest;
+import com.back.domain.comment.dto.CommentResponse;
+import com.back.domain.comment.entity.Comment;
+import com.back.domain.comment.enums.CommentSortType;
+import com.back.domain.comment.mapper.CommentMappers;
 import com.back.domain.comment.repository.CommentRepository;
+import com.back.domain.post.entity.Post;
+import com.back.domain.post.repository.PostRepository;
+import com.back.domain.user.entity.User;
+import com.back.domain.user.repository.UserRepository;
+import com.back.global.exception.ApiException;
+import com.back.global.exception.ErrorCode;
+import jakarta.validation.Valid;
 import lombok.RequiredArgsConstructor;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.domain.Sort;
 import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
 
 /**
  * 댓글 관련 비즈니스 로직을 처리하는 서비스.
  */
 @Service
 @RequiredArgsConstructor
+@Transactional(readOnly = true)
 public class CommentService {
 
+    private final UserRepository userRepository;
+    private final PostRepository postRepository;
     private final CommentRepository commentRepository;
 
+    public CommentResponse createComment(Long userId, Long postId, CommentRequest request) {
+        User user = userRepository.findById(userId)
+                .orElseThrow(() -> new ApiException(ErrorCode.USER_NOT_FOUND));
+
+        Post post = postRepository.findById(postId)
+                .orElseThrow(() -> new ApiException(ErrorCode.POST_NOT_FOUND));
+        CommentMappers.CommentCtxMapper ctxMapper = new CommentMappers.CommentCtxMapper(user, post);
+        Comment savedComment = commentRepository.save(ctxMapper.toEntity(request));
+        return ctxMapper.toResponse(savedComment);
+    }
+
+    public Page<CommentResponse> getComments(Long userId, Long postId, Pageable pageable) {
+        Post post = postRepository.findById(postId)
+                .orElseThrow(() -> new ApiException(ErrorCode.POST_NOT_FOUND));
+        Page<Comment> commentsPage = commentRepository.findCommentsByPostId(postId, pageable);
+        return commentsPage.map(CommentMappers.COMMENT_READ::map);
+    }
+
+    @Transactional
+    public Long updateComment(Long userId, Long commentId, CommentRequest request) {
+        Comment comment = commentRepository.findById(commentId)
+                .orElseThrow(() -> new ApiException(ErrorCode.COMMENT_NOT_FOUND));
+        comment.checkUser(userId);
+        comment.updateContent(request.content());
+        return comment.getId();
+    }
+
+    public void deleteComment(Long userId, Long commentId) {
+        Comment comment = commentRepository.findById(commentId)
+                .orElseThrow(() -> new ApiException(ErrorCode.COMMENT_NOT_FOUND));
+        comment.checkUser(userId);
+        commentRepository.delete(comment);
+    }
 }

back/src/main/java/com/back/domain/like/controller/LikeController.java

@@ -1,16 +1,31 @@
 package com.back.domain.like.controller;
 
 import com.back.domain.like.service.LikeService;
+import com.back.global.security.CustomUserDetails;
 import lombok.RequiredArgsConstructor;
-import org.springframework.web.bind.annotation.RestController;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.security.core.annotation.AuthenticationPrincipal;
+import org.springframework.web.bind.annotation.*;
 
 /**
  * 좋아요 관련 API 요청을 처리하는 컨트롤러.
  */
 @RestController
 @RequiredArgsConstructor
+@RequestMapping("/api/v1/posts")
 public class LikeController {
-
     private final LikeService likeService;
 
+    @PostMapping("/{postId}/likes")
+    public ResponseEntity<Void> addLike(@PathVariable Long postId, @AuthenticationPrincipal CustomUserDetails cs) {
+        likeService.addLike(cs.getUser().getId(), postId);
+        return ResponseEntity.status(HttpStatus.CREATED).body(null);
+    }
+
+    @DeleteMapping("/{postId}/likes")
+    public ResponseEntity<Void> removeLike(@PathVariable Long postId, @AuthenticationPrincipal CustomUserDetails cs) {
+        likeService.removeLike(postId, cs.getUser().getId());
+        return ResponseEntity.ok(null);
+    }
 }