[Seminar] 7주차 과제

build.gradle

@@ -23,6 +23,7 @@ dependencies {
     implementation 'org.springdoc:springdoc-openapi-starter-webmvc-ui:2.3.0'
     implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
     implementation 'com.google.code.gson:gson:2.10.1'
+    implementation 'com.fasterxml.jackson.datatype:jackson-datatype-jsr310'
     implementation 'org.springframework.boot:spring-boot-starter-validation'
 
     testImplementation 'org.springframework.boot:spring-boot-starter-test'
@@ -33,6 +34,9 @@ dependencies {
 
     compileOnly 'org.projectlombok:lombok'
     annotationProcessor 'org.projectlombok:lombok'
+
+    implementation 'org.springframework.boot:spring-boot-starter-data-redis'
+    implementation 'org.springframework.boot:spring-boot-starter-cache'
 }
 
 test {

src/main/java/org/sopt/domain/article/controller/ArticleController.java

@@ -3,19 +3,28 @@
 import jakarta.validation.Valid;
 import lombok.RequiredArgsConstructor;
 import org.sopt.domain.article.dto.request.ArticleCreateRequestDto;
-import org.sopt.domain.article.dto.response.ArticleResponseDto;
+import org.sopt.domain.article.dto.response.ArticleDetailResponseDto;
+import org.sopt.domain.article.dto.response.ArticleListResponseDto;
 import org.sopt.domain.article.service.ArticleService;
-import org.sopt.global.exception.constant.ArticleSuccessCode;
+import org.sopt.domain.comment.dto.request.CommentCreateRequestDto;
+import org.sopt.domain.comment.dto.response.CommentResponseDto;
+import org.sopt.domain.comment.service.CommentService;
+import org.sopt.global.exception.SuccessCode.ArticleSuccessCode;
+import org.sopt.global.exception.SuccessCode.CommentSuccessCode;
 import org.sopt.global.response.BaseResponse;
+import org.springdoc.core.annotations.ParameterObject;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.web.PageableDefault;
 import org.springframework.web.bind.annotation.*;
 
-import java.util.List;
-
 @RestController
 @RequiredArgsConstructor
 @RequestMapping("/articles")
 public class ArticleController {
+
     private final ArticleService articleService;
+    private final CommentService commentService;
 
     @PostMapping
     public BaseResponse<Long> createArticle(
@@ -26,19 +35,27 @@ public BaseResponse<Long> createArticle(
     }
 
     @GetMapping("/{articleId}")
-    public BaseResponse getArticle(
+    public BaseResponse<ArticleDetailResponseDto> getArticle(
             @PathVariable Long articleId
     ) {
-        ArticleResponseDto response = articleService.findOne(articleId);
-
+        ArticleDetailResponseDto response = articleService.findOne(articleId);
         return BaseResponse.ok(ArticleSuccessCode.GET_ARTICLE_SUCCESS.getMsg(), response);
     }
 
     @GetMapping
-    public BaseResponse<List<ArticleResponseDto>> getAllArticles() {
-        List<ArticleResponseDto> response = articleService.findAllArticles();
+    public BaseResponse<Page<ArticleListResponseDto>> getAllArticles(
+            @RequestParam(required = false) String keyword,
+            @ParameterObject @PageableDefault(size = 20) Pageable pageable) {
+        Page<ArticleListResponseDto> response = articleService.findAllArticles(keyword, pageable);
         return BaseResponse.ok(ArticleSuccessCode.GET_ALL_ARTICLES_SUCCESS.getMsg(), response);
     }
+
+    @PostMapping("/{articleId}/comments")
+    public BaseResponse<CommentResponseDto> createComment(@PathVariable Long articleId,
+                                                          @Valid @RequestBody CommentCreateRequestDto commentCreateRequestDto) {
+        CommentResponseDto response = commentService.createComment(articleId, commentCreateRequestDto);
+        return BaseResponse.ok(CommentSuccessCode.CREATE_COMMENT_SUCCESS.getMsg(), response);
+    }
 }
 
 

src/main/java/org/sopt/domain/article/domain/Article.java

@@ -11,6 +11,9 @@
 @Entity
 @Getter
 @NoArgsConstructor(access = AccessLevel.PROTECTED)
+@Table(name = "article", indexes = {
+        @Index(name = "idx_article_created_at", columnList = "created_at")
+})
 public class Article extends BaseTimeEntity {
     @Id
     @GeneratedValue(strategy = GenerationType.IDENTITY)

src/main/java/org/sopt/domain/article/dto/response/ArticleResponseDto.java → src/main/java/org/sopt/domain/article/dto/response/ArticleDetailResponseDto.java

@@ -3,27 +3,35 @@
 import lombok.Builder;
 import org.sopt.domain.article.domain.Article;
 import org.sopt.domain.article.domain.enums.Tag;
+import org.sopt.domain.comment.domain.Comment;
+import org.sopt.domain.comment.dto.response.CommentResponseDto;
 
 import java.time.LocalDateTime;
+import java.util.List;
 
 @Builder
-public record ArticleResponseDto(
+public record ArticleDetailResponseDto(
         Long id,
         Long memberId,
         String memberName,
         Tag tag,
         String title,
         String content,
+        List<CommentResponseDto> comments,
         LocalDateTime publishedAt) {
 
-    public static ArticleResponseDto fromEntity(Article article) {
-        return ArticleResponseDto.builder()
+    public static ArticleDetailResponseDto fromEntity(Article article, List<Comment> comments) {
+        return ArticleDetailResponseDto.builder()
                 .id(article.getId())
                 .memberId(article.getMember().getId())
                 .memberName(article.getMember().getName())
                 .tag(article.getTag())
                 .title(article.getTitle())
                 .content(article.getContent())
+                .comments(comments.stream()
+                        .map(CommentResponseDto::fromEntity)
+                        .toList())
+                .publishedAt(article.getCreatedAt())
                 .build();
     }
 }

src/main/java/org/sopt/domain/article/dto/response/ArticleListResponseDto.java

@@ -0,0 +1,29 @@
+package org.sopt.domain.article.dto.response;
+
+import lombok.*;
+import org.sopt.domain.article.domain.Article;
+import org.sopt.domain.article.domain.enums.Tag;
+
+import java.time.LocalDateTime;
+
+@Getter
+@NoArgsConstructor(access = AccessLevel.PRIVATE)
+@AllArgsConstructor
+@Builder
+public class ArticleListResponseDto {
+    private Long id;
+    private String memberName;
+    private Tag tag;
+    private String title;
+    private LocalDateTime createdAt;
+
+    public static ArticleListResponseDto fromEntity(Article article) {
+        return ArticleListResponseDto.builder()
+                .id(article.getId())
+                .memberName(article.getMember().getName())
+                .tag(article.getTag())
+                .title(article.getTitle())
+                .createdAt(article.getCreatedAt())
+                .build();
+    }
+}

src/main/java/org/sopt/domain/article/repository/ArticleRepository.java

@@ -1,14 +1,27 @@
 package org.sopt.domain.article.repository;
 
 import org.sopt.domain.article.domain.Article;
+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 java.util.List;
 import java.util.Optional;
 
 public interface ArticleRepository extends JpaRepository<Article, Long> {
-    @Query("SELECT a FROM Article a JOIN FETCH a.member")
-    List<Article> findAllWithMember();
+    @Query(value = "SELECT a FROM Article a JOIN FETCH a.member",
+            countQuery = "SELECT COUNT(a) FROM Article a")
+    Page<Article> findAllWithMember(Pageable pageable);
+
+    @Query(value = "SELECT a FROM Article a JOIN FETCH a.member m " +
+            "WHERE a.title LIKE %:keyword% OR m.name LIKE %:keyword%",
+            countQuery = "SELECT COUNT(a) FROM Article a JOIN a.member m " +
+                    "WHERE a.title LIKE %:keyword% OR m.name LIKE %:keyword%")   Page<Article> searchByKeyword(@Param("keyword") String keyword, Pageable pageable);
+
+    @Query("SELECT a FROM Article a JOIN FETCH a.member WHERE a.id = :id")
+    Optional<Article> findWithMemberById(@Param("id") Long id);
+
     Optional<Article> findByTitle(String title);
+
 }

src/main/java/org/sopt/domain/article/service/ArticleService.java

@@ -1,12 +1,13 @@
 package org.sopt.domain.article.service;
 
 import org.sopt.domain.article.dto.request.ArticleCreateRequestDto;
-import org.sopt.domain.article.dto.response.ArticleResponseDto;
-
-import java.util.List;
+import org.sopt.domain.article.dto.response.ArticleDetailResponseDto;
+import org.sopt.domain.article.dto.response.ArticleListResponseDto;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
 
 public interface ArticleService {
     Long createArticle(ArticleCreateRequestDto request);
-    ArticleResponseDto findOne(Long articleId);
-    List<ArticleResponseDto> findAllArticles();
+    ArticleDetailResponseDto findOne(Long articleId);
+    Page<ArticleListResponseDto> findAllArticles(String keyword, Pageable pageable);
 }

src/main/java/org/sopt/domain/article/service/ArticleServiceImpl.java

@@ -3,12 +3,19 @@
 import lombok.RequiredArgsConstructor;
 import org.sopt.domain.article.domain.Article;
 import org.sopt.domain.article.dto.request.ArticleCreateRequestDto;
-import org.sopt.domain.article.dto.response.ArticleResponseDto;
+import org.sopt.domain.article.dto.response.ArticleDetailResponseDto;
+import org.sopt.domain.article.dto.response.ArticleListResponseDto;
 import org.sopt.domain.article.repository.ArticleRepository;
+import org.sopt.domain.comment.domain.Comment;
+import org.sopt.domain.comment.repository.CommentRepository;
 import org.sopt.domain.member.domain.Member;
 import org.sopt.domain.member.repository.MemberRepository;
 import org.sopt.global.exception.CustomException;
-import org.sopt.global.exception.constant.GlobalErrorCode;
+import org.sopt.global.exception.ErrorCode.GlobalErrorCode;
+import org.springframework.cache.annotation.CacheEvict;
+import org.springframework.cache.annotation.Cacheable;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
@@ -21,9 +28,11 @@ public class ArticleServiceImpl implements ArticleService {
 
     private final ArticleRepository articleRepository;
     private final MemberRepository memberRepository;
+    private final CommentRepository commentRepository;
 
     @Override
     @Transactional
+    @CacheEvict(value = "articleList", allEntries = true, cacheManager = "cacheManager")
     public Long createArticle(ArticleCreateRequestDto request) {
 
         Member member = memberRepository.findById(request.memberId())
@@ -46,17 +55,26 @@ public Long createArticle(ArticleCreateRequestDto request) {
     }
 
     @Override
-    public ArticleResponseDto findOne(Long articleId) {
-        Article article = articleRepository.findById(articleId)
+    @Cacheable(value = "article", key = "#articleId", cacheManager = "cacheManager")
+    public ArticleDetailResponseDto findOne(Long articleId) {
+        Article article = articleRepository.findWithMemberById(articleId)
                 .orElseThrow(() -> new CustomException(GlobalErrorCode.ARTICLE_NOT_FOUND));
 
-        return ArticleResponseDto.fromEntity(article);
+        List<Comment> comments = commentRepository.findAllByArticleWithMember(article);
+        return ArticleDetailResponseDto.fromEntity(article, comments);
     }
 
     @Override
-    public List<ArticleResponseDto> findAllArticles() {
-        return articleRepository.findAllWithMember().stream()
-                .map(ArticleResponseDto::fromEntity)
-                .toList();
+    @Cacheable(value = "articleList", key = "'all'", cacheManager = "cacheManager")
+    public Page<ArticleListResponseDto> findAllArticles(String keyword, Pageable pageable) {
+        Page<Article> articles;
+
+        if (keyword == null || keyword.isEmpty()) {
+            articles = articleRepository.findAllWithMember(pageable);
+        } else {
+            articles = articleRepository.searchByKeyword(keyword, pageable);
+        }
+
+        return articles.map(ArticleListResponseDto::fromEntity);
     }
 }

src/main/java/org/sopt/domain/comment/controller/CommentController.java

@@ -0,0 +1,36 @@
+package org.sopt.domain.comment.controller;
+
+import jakarta.validation.Valid;
+import lombok.RequiredArgsConstructor;
+import org.sopt.domain.comment.dto.request.CommentUpdateRequestDto;
+import org.sopt.domain.comment.dto.response.CommentResponseDto;
+import org.sopt.domain.comment.service.CommentService;
+import org.sopt.global.exception.SuccessCode.CommentSuccessCode;
+import org.sopt.global.response.BaseResponse;
+import org.springframework.web.bind.annotation.*;
+
+@RestController
+@RequiredArgsConstructor
+@RequestMapping("/comments/{commentId}")
+public class CommentController {
+
+    private final CommentService commentService;
+    @PutMapping
+    public BaseResponse<CommentResponseDto> updateComment(@PathVariable Long commentId,
+                                                          @Valid @RequestBody CommentUpdateRequestDto commentUpdateRequestDto) {
+        CommentResponseDto response = commentService.updateComment(commentId, commentUpdateRequestDto);
+        return BaseResponse.ok(CommentSuccessCode.UPDATE_COMMENT_SUCCESS.getMsg(), response);
+    }
+
+    @DeleteMapping
+    public BaseResponse<Void> deleteComment(@PathVariable Long commentId) {
+        commentService.deleteComment(commentId);
+        return BaseResponse.ok(CommentSuccessCode.DELETE_COMMENT_SUCCESS.getMsg(), null);
+    }
+
+    @GetMapping
+    public BaseResponse<CommentResponseDto> getComment(@PathVariable Long commentId){
+        CommentResponseDto response = commentService.getComment(commentId);
+        return BaseResponse.ok(CommentSuccessCode.GET_COMMENT_SUCCESS.getMsg(), response);
+    }
+}

src/main/java/org/sopt/domain/comment/domain/Comment.java

@@ -0,0 +1,57 @@
+package org.sopt.domain.comment.domain;
+
+import jakarta.persistence.*;
+import lombok.AccessLevel;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import org.hibernate.annotations.SQLRestriction;
+import org.sopt.domain.article.domain.Article;
+import org.sopt.domain.member.domain.Member;
+import org.sopt.global.entity.BaseTimeEntity;
+
+@Entity
+@Getter
+@NoArgsConstructor(access = AccessLevel.PROTECTED)
+@SQLRestriction("is_deleted = false")
+@Table(name = "comment", indexes = {
+        @Index(name = "idx_comment_article_id", columnList = "article_id")
+})
+public class Comment extends BaseTimeEntity {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @Column(nullable = false, length = 300)
+    private String content;
+
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "article_id")
+    private Article article;
+
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "comment_id")
+    private Member member;
+
+    private boolean isDeleted = false;
+
+    @Builder
+    private Comment(String content, Article article, Member member) {
+        this.content = content;
+        this.article = article;
+        this.member = member;
+    }
+
+    public static Comment create(String content, Article article, Member member) {
+        return new Comment(content, article, member);
+    }
+
+    public void updateComment(String content) {
+        this.content = content;
+    }
+
+    public void softDelete() {
+        this.isDeleted = true;
+    }
+}

src/main/java/org/sopt/domain/comment/dto/request/CommentCreateRequestDto.java

@@ -0,0 +1,8 @@
+package org.sopt.domain.comment.dto.request;
+
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.NotNull;
+import jakarta.validation.constraints.Size;
+
+public record CommentCreateRequestDto(@NotNull Long memberId, @NotBlank @Size(max = 300) String content) {
+}

src/main/java/org/sopt/domain/comment/dto/request/CommentUpdateRequestDto.java

@@ -0,0 +1,8 @@
+package org.sopt.domain.comment.dto.request;
+
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.Size;
+
+public record CommentUpdateRequestDto(@NotBlank @Size(max = 300) String content) {
+}
+