댓글 작성 기능 구현

backend/src/main/java/com/votogether/config/OpenAPIConfig.java

@@ -1,7 +1,12 @@
 package com.votogether.config;
 
+import io.swagger.v3.oas.models.Components;
 import io.swagger.v3.oas.models.OpenAPI;
 import io.swagger.v3.oas.models.info.Info;
+import io.swagger.v3.oas.models.security.SecurityRequirement;
+import io.swagger.v3.oas.models.security.SecurityScheme;
+import io.swagger.v3.oas.models.security.SecurityScheme.In;
+import io.swagger.v3.oas.models.security.SecurityScheme.Type;
 import io.swagger.v3.oas.models.servers.Server;
 import java.util.List;
 import org.springframework.beans.factory.annotation.Value;
@@ -37,9 +42,22 @@ public OpenAPI openAPI() {
                 .version("v1.0.0")
                 .description("보투게더 API");
 
+        final SecurityScheme securityScheme = new SecurityScheme()
+                .type(Type.HTTP)
+                .in(In.HEADER)
+                .name("Authorization")
+                .scheme("bearer")
+                .bearerFormat("JWT")
+                .description("Bearer JWT");
+
+        final SecurityRequirement securityRequirement = new SecurityRequirement()
+                .addList("bearerAuth");
+
         return new OpenAPI()
                 .info(info)
-                .servers(List.of(devServer, prodServer));
+                .servers(List.of(devServer, prodServer))
+                .components(new Components().addSecuritySchemes("bearerAuth", securityScheme))
+                .security(List.of(securityRequirement));
     }
 
 }

backend/src/main/java/com/votogether/domain/post/controller/PostCommentController.java

@@ -0,0 +1,52 @@
+package com.votogether.domain.post.controller;
+
+import com.votogether.domain.member.entity.Member;
+import com.votogether.domain.post.dto.request.CommentRegisterRequest;
+import com.votogether.domain.post.service.PostCommentService;
+import com.votogether.exception.ExceptionResponse;
+import com.votogether.global.jwt.Auth;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.Parameter;
+import io.swagger.v3.oas.annotations.media.Content;
+import io.swagger.v3.oas.annotations.media.Schema;
+import io.swagger.v3.oas.annotations.responses.ApiResponse;
+import io.swagger.v3.oas.annotations.responses.ApiResponses;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import jakarta.validation.Valid;
+import lombok.RequiredArgsConstructor;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+@Tag(name = "게시글 댓글", description = "게시글 댓글 API")
+@RequiredArgsConstructor
+@RequestMapping("/posts")
+@RestController
+public class PostCommentController {
+
+    private final PostCommentService postCommentService;
+
+    @Operation(summary = "게시글 댓글 작성", description = "게시글 댓글을 작성한다.")
+    @ApiResponses({
+            @ApiResponse(responseCode = "200", description = "게시글 댓글 작성 성공"),
+            @ApiResponse(
+                    responseCode = "404",
+                    description = "존재하지 않는 게시글에 대한 댓글 작성",
+                    content = @Content(schema = @Schema(implementation = ExceptionResponse.class))
+            )
+    })
+    @PostMapping("/{postId}/comments")
+    public ResponseEntity<Void> registerComment(
+            @Auth final Member member,
+            @PathVariable @Parameter(description = "댓글 작성 게시글 ID") final Long postId,
+            @Valid @RequestBody CommentRegisterRequest commentRegisterRequest
+    ) {
+        postCommentService.registerComment(member, postId, commentRegisterRequest);
+        return ResponseEntity.status(HttpStatus.CREATED).build();
+    }
+
+}

backend/src/main/java/com/votogether/domain/post/dto/request/CommentRegisterRequest.java

@@ -0,0 +1,12 @@
+package com.votogether.domain.post.dto.request;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import jakarta.validation.constraints.NotBlank;
+
+@Schema(description = "게시글 댓글 작성 요청")
+public record CommentRegisterRequest(
+        @Schema(description = "댓글 내용", example = "hello")
+        @NotBlank(message = "댓글 내용은 존재해야 합니다.")
+        String content
+) {
+}

backend/src/main/java/com/votogether/domain/post/entity/Post.java

@@ -3,9 +3,11 @@
 import com.votogether.domain.category.entity.Category;
 import com.votogether.domain.common.BaseEntity;
 import com.votogether.domain.member.entity.Member;
+import com.votogether.domain.post.entity.comment.Comment;
 import com.votogether.domain.post.exception.PostExceptionType;
 import com.votogether.domain.vote.entity.Vote;
 import com.votogether.exception.BadRequestException;
+import jakarta.persistence.CascadeType;
 import jakarta.persistence.Column;
 import jakarta.persistence.Embedded;
 import jakarta.persistence.Entity;
@@ -15,7 +17,9 @@
 import jakarta.persistence.Id;
 import jakarta.persistence.JoinColumn;
 import jakarta.persistence.ManyToOne;
+import jakarta.persistence.OneToMany;
 import java.time.LocalDateTime;
+import java.util.ArrayList;
 import java.util.List;
 import java.util.Objects;
 import java.util.stream.IntStream;
@@ -50,6 +54,9 @@ public class Post extends BaseEntity {
     @Column(columnDefinition = "datetime(2)", nullable = false)
     private LocalDateTime deadline;
 
+    @OneToMany(mappedBy = "post", cascade = CascadeType.PERSIST)
+    private List<Comment> comments = new ArrayList<>();
+
     @Builder
     private Post(
             final Member member,
@@ -129,4 +136,9 @@ private void validatePostOption(PostOption postOption) {
         }
     }
 
+    public void addComment(final Comment comment) {
+        comments.add(comment);
+        comment.setPost(this);
+    }
+
 }

backend/src/main/java/com/votogether/domain/post/entity/comment/Comment.java

@@ -0,0 +1,48 @@
+package com.votogether.domain.post.entity.comment;
+
+import com.votogether.domain.common.BaseEntity;
+import com.votogether.domain.member.entity.Member;
+import com.votogether.domain.post.entity.Post;
+import jakarta.persistence.Embedded;
+import jakarta.persistence.Entity;
+import jakarta.persistence.FetchType;
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.GenerationType;
+import jakarta.persistence.Id;
+import jakarta.persistence.JoinColumn;
+import jakarta.persistence.ManyToOne;
+import lombok.AccessLevel;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@NoArgsConstructor(access = AccessLevel.PROTECTED)
+@Getter
+@Entity
+public class Comment extends BaseEntity {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @Setter
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "post_id", nullable = false)
+    private Post post;
+
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "member_id", nullable = false)
+    private Member member;
+
+    @Embedded
+    private Content content;
+
+    @Builder
+    private Comment(final Post post, final Member member, final String content) {
+        this.post = post;
+        this.member = member;
+        this.content = new Content(content);
+    }
+
+}

backend/src/main/java/com/votogether/domain/post/entity/comment/Content.java

@@ -0,0 +1,35 @@
+package com.votogether.domain.post.entity.comment;
+
+import com.votogether.domain.post.exception.CommentExceptionType;
+import com.votogether.exception.BadRequestException;
+import jakarta.persistence.Column;
+import jakarta.persistence.Embeddable;
+import lombok.AccessLevel;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+
+@NoArgsConstructor(access = AccessLevel.PROTECTED)
+@Getter
+@Embeddable
+class Content {
+
+    private static final int MAXIMUM_LENGTH = 500;
+
+    @Column(name = "content", nullable = false, length = MAXIMUM_LENGTH)
+    private String value;
+
+    public Content(final String value) {
+        validate(value);
+        this.value = value;
+    }
+
+    private void validate(final String content) {
+        if (content.length() > MAXIMUM_LENGTH) {
+            throw new BadRequestException(
+                    CommentExceptionType.INVALID_CONTENT_LENGTH.getCode(),
+                    String.format("댓글 길이는 최대 %d자까지 가능합니다.", MAXIMUM_LENGTH)
+            );
+        }
+    }
+
+}

backend/src/main/java/com/votogether/domain/post/exception/CommentExceptionType.java

@@ -0,0 +1,19 @@
+package com.votogether.domain.post.exception;
+
+import com.votogether.exception.ExceptionType;
+import lombok.Getter;
+
+@Getter
+public enum CommentExceptionType implements ExceptionType {
+
+    INVALID_CONTENT_LENGTH(2000, "유효하지 않은 댓글 길이입니다.");
+
+    private final int code;
+    private final String message;
+
+    CommentExceptionType(final int code, final String message) {
+        this.code = code;
+        this.message = message;
+    }
+
+}

backend/src/main/java/com/votogether/domain/post/repository/CommentRepository.java

@@ -0,0 +1,7 @@
+package com.votogether.domain.post.repository;
+
+import com.votogether.domain.post.entity.comment.Comment;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+public interface CommentRepository extends JpaRepository<Comment, Long> {
+}

backend/src/main/java/com/votogether/domain/post/service/PostCommentService.java

@@ -0,0 +1,37 @@
+package com.votogether.domain.post.service;
+
+import com.votogether.domain.member.entity.Member;
+import com.votogether.domain.post.dto.request.CommentRegisterRequest;
+import com.votogether.domain.post.entity.Post;
+import com.votogether.domain.post.entity.comment.Comment;
+import com.votogether.domain.post.exception.PostExceptionType;
+import com.votogether.domain.post.repository.PostRepository;
+import com.votogether.exception.BadRequestException;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+@RequiredArgsConstructor
+@Service
+public class PostCommentService {
+
+    private final PostRepository postRepository;
+
+    @Transactional
+    public void registerComment(
+            final Member member,
+            final Long postId,
+            final CommentRegisterRequest commentRegisterRequest
+    ) {
+        final Post post = postRepository.findById(postId)
+                .orElseThrow(() -> new BadRequestException(PostExceptionType.POST_NOT_FOUND));
+
+        post.addComment(
+                Comment.builder()
+                        .member(member)
+                        .content(commentRegisterRequest.content())
+                        .build()
+        );
+    }
+
+}

backend/src/main/java/com/votogether/exception/BadRequestException.java

@@ -6,4 +6,8 @@ public BadRequestException(final ExceptionType exceptionType) {
         super(exceptionType);
     }
 
+    public BadRequestException(final int code, final String message) {
+        super(code, message);
+    }
+
 }

backend/src/main/java/com/votogether/exception/BaseException.java

@@ -5,11 +5,16 @@
 @Getter
 public class BaseException extends RuntimeException {
 
-    private final ExceptionType exceptionType;
+    private final int code;
 
     public BaseException(final ExceptionType exceptionType) {
         super(exceptionType.getMessage());
-        this.exceptionType = exceptionType;
+        this.code = exceptionType.getCode();
+    }
+
+    public BaseException(final int code, final String message) {
+        super(message);
+        this.code = code;
     }
 
 }

backend/src/main/java/com/votogether/exception/ExceptionResponse.java

@@ -1,10 +1,17 @@
 package com.votogether.exception;
 
-public record ExceptionResponse(int code, String message) {
+import io.swagger.v3.oas.annotations.media.Schema;
+
+@Schema(description = "예외 발생 응답")
+public record ExceptionResponse(
+        @Schema(description = "예외 코드", example = "-9999")
+        int code,
+        @Schema(description = "예외 메시지", example = "알 수 없는 서버 예외가 발생하였습니다.")
+        String message
+) {
 
     public static ExceptionResponse from(final BaseException e) {
-        final ExceptionType exceptionType = e.getExceptionType();
-        return new ExceptionResponse(exceptionType.getCode(), exceptionType.getMessage());
+        return new ExceptionResponse(e.getCode(), e.getMessage());
     }
 
 }

backend/src/main/java/com/votogether/exception/GlobalExceptionHandler.java

@@ -1,10 +1,13 @@
 package com.votogether.exception;
 
+import java.util.List;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.http.HttpStatus;
 import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.MethodArgumentNotValidException;
 import org.springframework.web.bind.annotation.ExceptionHandler;
 import org.springframework.web.bind.annotation.RestControllerAdvice;
+import org.springframework.web.method.annotation.MethodArgumentTypeMismatchException;
 
 @Slf4j
 @RestControllerAdvice
@@ -17,6 +20,34 @@ public ResponseEntity<ExceptionResponse> handleException(final Exception e) {
                 .body(new ExceptionResponse(-9999, "알 수 없는 서버 에러가 발생했습니다."));
     }
 
+    @ExceptionHandler
+    public ResponseEntity<ExceptionResponse> handleMethodArgumentTypeMismatchException(
+            final MethodArgumentTypeMismatchException e
+    ) {
+        final String errorMessage = String.format(
+                "%s는 %s 타입이 필요합니다.",
+                e.getPropertyName(),
+                e.getRequiredType().getSimpleName()
+        );
+        log.warn("[" + e.getClass() + "] : " + errorMessage);
+        return ResponseEntity.badRequest()
+                .body(new ExceptionResponse(-9998, errorMessage));
+    }
+
+    @ExceptionHandler
+    public ResponseEntity<ExceptionResponse> handleMethodArgumentNotValidException(
+            final MethodArgumentNotValidException e
+    ) {
+        final List<String> errorMessages = e.getBindingResult()
+                .getAllErrors()
+                .stream()
+                .map(error -> error.getDefaultMessage())
+                .toList();
+        log.warn("[" + e.getClass() + "] : " + errorMessages);
+        return ResponseEntity.badRequest()
+                .body(new ExceptionResponse(-9997, errorMessages.toString()));
+    }
+
     @ExceptionHandler
     public ResponseEntity<ExceptionResponse> handleBadRequestException(final BadRequestException e) {
         log.warn("[" + e.getClass() + "] : " + e.getMessage());