스프링부트 게시판 API 만들기 (15) - 게시글 조회&검색 서비스 구현(1) (+ 테스트 환경 분리, 더미 데이터 입력)

 

 

 

 

 

 

 

오랜만에 글을 쓰는 거 같네요.. 리눅스랑 뭐 이것저것 공부한다고 바뻐서...ㅠㅠ

오늘은 QueryDSL을 사용해서 게시판 검색(조건에 따른 동적 검색), 페이징, 조회 기능을 구현하여 기본적인 게시판을 완성시켜 보도록 하겠습니다!

 

• 시큐리티를 이용한 JSON 데이터로 로그인 (완료)
• JWT를 이용한 인증 (완료)
• 도메인, 테이블 설계, 엔티티 생성 (완료)
• 댓글 삭제 로직 구현 (완료)
• 회원가입 + 정보수정 등 회원 서비스 구현 (완료)
• 게시판 서비스 구현 (진행 중)
• 댓글 서비스 구현 (1댓글 -> *(무한) 대댓글 구조) (완료)
• 예외 처리 (완료)
• 예외 메세지 국제화
• 카테고리별 게시판 분류
• 게시글 페이징 (진행 중)
• 동적인 검색 조건을 사용한 검색 (진행 중)
• 사용자 간 쪽지 기능
• 무한 쪽지 스크롤
• 게시물 & 댓글에 대한 알람
• 쪽지에 대한 알람
• 접속한 사용자 간 실시간 채팅
• 회원가입 시 검증(예: XX대학교 XX과가 아니면 가입할 수 없게)
• Swagger를 사용한 API 문서 만들기
• 신고 & 블랙리스트 기능
• AOP를 통한 로그
• 어드민 페이지
• 캐시
• 배포 (+ 무중단 배포)
• 배포 자동화
• 포트와 어댑터 설계를 따르는 패키지 구조 설계하기
• ...

 

 

 

 

 

 

 

 

 

 

 

 

QueryDSL 의존성 추가

QueryDSL을 사용하여 구현할 것이기 때문에 의존성을 추가해 주도록 하겠습니다.

 

(혹시 아래 설정이 작동하지 않는다면, 아래 사이트도 참고해주세요.

https://ttl-blog.tistory.com/855?category=906290 )

 

build.gradle에 추가

plugins {
   ...
   
   //QueryDSL 추가
   id "com.ewerk.gradle.plugins.querydsl" version "1.0.10"
}

 

dependencies {
   ...

   //QueryDSL 추가
   implementation 'com.querydsl:querydsl-jpa:5.0.0'
   annotationProcessor group: 'com.querydsl', name: 'querydsl-apt', version: '5.0.0'
}

 

 

 

(다음은 맨 아래에 바로 추가해주시면 됩니다.)

//querydsl 추가 시작
def querydslDir = "$buildDir/generated/querydsl"

querydsl {
   jpa = true
   querydslSourcesDir = querydslDir
}
sourceSets {
   main.java.srcDir querydslDir
}
compileQuerydsl{
   options.annotationProcessorPath = configurations.querydsl
}

configurations {
   compileOnly {
      extendsFrom annotationProcessor
   }
   querydsl.extendsFrom compileClasspath
}
//querydsl 추가 끝

 

 

 

 

 

 

전체 build.gradle

plugins {
   id 'org.springframework.boot' version '2.6.2'
   id 'io.spring.dependency-management' version '1.0.11.RELEASE'
   id 'java'

   id "com.ewerk.gradle.plugins.querydsl" version "1.0.10"
}

group = 'boardexample'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = '17'

configurations {
   compileOnly {
      extendsFrom annotationProcessor
   }
}

repositories {
   mavenCentral()
}

dependencies {
   implementation 'org.springframework.boot:spring-boot-starter-data-jpa'

   implementation 'org.springframework.boot:spring-boot-starter-security'

   implementation 'org.springframework.boot:spring-boot-starter-validation'

   implementation 'org.springframework.boot:spring-boot-starter-web'

   compileOnly 'org.projectlombok:lombok'
   runtimeOnly 'com.h2database:h2'
   annotationProcessor 'org.projectlombok:lombok'

   testImplementation 'org.springframework.boot:spring-boot-starter-test'
   testImplementation 'org.springframework.security:spring-security-test'

   //p6spy 적용
   implementation 'com.github.gavlyukovskiy:p6spy-spring-boot-starter:1.7.1'

   //JWT
   implementation 'com.auth0:java-jwt:3.18.2'

   //QueryDSL
   implementation 'com.querydsl:querydsl-jpa:5.0.0'
   annotationProcessor group: 'com.querydsl', name: 'querydsl-apt', version: '5.0.0'
}

test {
   useJUnitPlatform()
}


//querydsl 추가 시작
def querydslDir = "$buildDir/generated/querydsl"

querydsl {
   jpa = true
   querydslSourcesDir = querydslDir
}
sourceSets {
   main.java.srcDir querydslDir
}
compileQuerydsl{
   options.annotationProcessorPath = configurations.querydsl
}

configurations {
   compileOnly {
      extendsFrom annotationProcessor
   }
   querydsl.extendsFrom compileClasspath
}
//querydsl 추가 끝

 

 

 

 

 

 

 

 

제대로 추가되었는지 확인하기 위해 인텔리제이 우측의 Gradle -> Tasks -> other -> complieQuerydsl을 클릭해줍시다.

다음과 같이 나왔다면 성공입니다!

(저 테마 바꿨는데 이뻐서 맘에듭니다 ㅎㅎ.)

 

 

 

그리고 성공하셨다면 build 파일과, 그 안에 querydsl 파일 속에 Q타입 파일들이 생기셨을겁니다

그렇다면 이제 QueryDSL을 사용할 준비가 정말 다 끝난겁니다

 

 

 

 

 

 

 

 

 

 

 

 

 

application.yml 변경

 

 

추가할 설정들은 다음과 같습니다.

 

1. 페이징 할 때 기본 페이징 개수

2. 파일 업로드 시, 파일의 개당 크기 & 모든 파일의 총량 제한 (저번에 구현할 때 했어야 했는데... 안했었습니다..ㅠㅠ)

3. OSIV 사용 X

4. default_batch_fetch_size 지정(Collection 조회 쿼리 최적화를 위함)

5. 테스트 환경 분리하기

(이제부터는 일반 애플리케이션 환경에서는 더미 데이터를 입력해두고 사용할 것이기 때문에, 테스트코드와의 환경을 분리하여

테스트코드는 더미 데이터 없이 기존의 테스트코드가 잘 작동하도록 만들어주겠습니다.)

 

 

 

 

 

 

 

추가한 부분은 주석을 달았습니다.

(설정이 조금씩 바뀐 부분이 있습니다. 비교해가면서, 알아서 설정해주세요!)

spring:
  datasource:
    driver-class-name: org.h2.Driver
    url: jdbc:h2:tcp://localhost/~/jpa
    username: sa
    password: 1
  data:
    web:
      pageable:
        default-page-size: 20  #페이징 할 때 기본값, 20개씩 조회



  servlet:
    multipart:
      max-request-size: 5MB  #업로드 파일 크기 총량 제한
      max-file-size: 2MB     #업로드 파일 크기 제한



  jpa:
    show-sql: true  #P6spy와 함께, SQL 로그도 보도록 하겠습니다..! 안해주셔도 무방합니다만, P6spy가 너무 안 이쁘게 보여줘서...ㅠㅠ
    properties:
      hibernate:
        format_sql: true
        user_sql_cooments: true

        default_batch_fetch_size: 500 #배치 사이즈 (Collection 조회 최적화)

    hibernate:
      ddl-auto: none ##이제 배포환경에서는 create를 사용하지 않겠습니다.


    open-in-view: false #OSIV 사용하지 않기


  profiles:
    include: jwt



logging:
  level:
    org:
      apache:
        coyote:
          http11: OFF #저는 HTTP로그를 사용하지 않겠습니다. 사용하셔도 무방합니다.

      hiberante:
        SQL: debug

    boardexample:
      myboard: info



file:
  dir: D:\files\

 

 

 

 

 

 

 

 

 

 

 

테스트 환경 분리하기

다음 위치에 application.yml 파일을 추가합니다.

main이 아니라 test폴더 하위에 resources를 만들어 주었습니다.

 

 

 

 

 

 

테스트환경 application.yml

다음과 같습니다.

(이제부터 테스트 환경에서는 임베디드 방식의 H2데이터베이스를 사용하도록 합니다.)

spring:

  profiles:
    include: jwt

  datasource:
    driver-class-name: org.h2.Driver
    username: sa


  data:
    web:
      pageable:
        default-page-size: 20 




  servlet:
    multipart:
      max-request-size: 5MB 
      max-file-size: 2MB    



  jpa:
    show-sql: true
    properties:
      hibernate:
        format_sql: true
        user_sql_cooments: true


        default_batch_fetch_size: 100

    hibernate:
      ddl-auto: create


    open-in-view: false 


  h2:
    console:
      enabled: true ##임베디드 방식의 H2디비 사용





logging:
  level:
    org:
      apache:
        coyote:
          http11: OFF #debug

      hiberante:
        SQL: debug

    boardexample:
      myboard: info



file:
  dir: D:\files\

 

 

 

 

 

 

 

 

 

 

 

 

 

 

Member 클래스 수정

Member에서 다음 두 필드에 대해서 추가 작업을 해주어야 합니다.

//== 회원탈퇴 -> 작성한 게시물, 댓글 모두 삭제 ==//
@OneToMany(mappedBy = "writer", cascade = ALL, orphanRemoval = true)
private List<Post> postList = new ArrayList<>();

@OneToMany(mappedBy = "writer", cascade = ALL, orphanRemoval = true)
private List<Comment> commentList = new ArrayList<>();

위의 두 필드가 있습니다.

 

 

저는 현재 클래스에 @Builder를 붙였기에, new ArrayList();로 초기화를 시켜줬음에도 불구하고 빌더를 통해 Member를 생성하면 위 두 필드는 null이 들어오게 됩니다.

 

 

 

이를 해결하기 위해 다음 어노테이션을 붙여주겠습니다.

@Builder.Default

 

 

 

 

코드는 다음과 같습니다.

import static javax.persistence.CascadeType.ALL;
import static javax.persistence.EnumType.*;
import static javax.persistence.GenerationType.*;

@Table(name = "MEMBER")
@Getter
@NoArgsConstructor(access = AccessLevel.PROTECTED)
@Entity
@AllArgsConstructor
@Builder
public class Member extends BaseTimeEntity {


    @Id @GeneratedValue(strategy = IDENTITY)
    @Column(name = "member_id")
    private Long id; //primary Key



    @Column(nullable = false, length = 30, unique = true)
    private String username;//아이디

    private String password;//비밀번호


    @Column(nullable = false, length = 30)
    private String name;//이름(실명)


    @Column(nullable = false, length = 30)
    private String nickName;//별명


    @Column(nullable = false, length = 30)
    private Integer age;//나이



    @Enumerated(STRING)
    @Column(nullable = false, length = 30)
    private Role role;//권한 -> USER, ADMIN


    @Column(length = 1000)
    private String refreshToken;//RefreshToken



    //== 회원탈퇴 -> 작성한 게시물, 댓글 모두 삭제 ==//
    @Builder.Default
    @OneToMany(mappedBy = "writer", cascade = ALL, orphanRemoval = true)
    private List<Post> postList = new ArrayList<>();

    @Builder.Default
    @OneToMany(mappedBy = "writer", cascade = ALL, orphanRemoval = true)
    private List<Comment> commentList = new ArrayList<>();





    //== 연관관계 메서드 ==//
    public void addPost(Post post){
        //post의 writer 설정은 post에서 함
        postList.add(post);
    }

    public void addComment(Comment comment){
        //comment의 writer 설정은 comment에서 함
        commentList.add(comment);
    }







    //== 정보 수정 ==//
    public void updatePassword(PasswordEncoder passwordEncoder, String password){
        this.password = passwordEncoder.encode(password);
    }

    public void updateName(String name){
        this.name = name;
    }

    public void updateNickName(String nickName){
        this.nickName = nickName;
    }

    public void updateAge(int age){
        this.age = age;
    }

    public void updateRefreshToken(String refreshToken){
        this.refreshToken = refreshToken;
    }
    public void destroyRefreshToken(){
        this.refreshToken = null;
    }


    /**
     * 패스워드 암호화
     */
    public void encodePassword(PasswordEncoder passwordEncoder){
        this.password = passwordEncoder.encode(password);
    }


    /**
     * 패스워드 일치하는지 확인
     * @param passwordEncoder 패스워드 인코더
     * @param checkPassword 검사할 비밀번호
     * @return
     */
    public boolean matchPassword(PasswordEncoder passwordEncoder, String checkPassword){
        return passwordEncoder.matches(checkPassword, getPassword());
    }


    //== 권한 부여 ==//
    public void addUserAuthority() {
        this.role = Role.USER;
    }


}

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

PostServiceImpl 추가 구현

현재 저희는 getPostInfo와 getPostList메서드를 구현하지 않았습니다.

우선 게시글 하나를 조회하는 getPostInfo부터 구현해 보겠습니다.

 

/**
 * Post의 id를 통해 Post 조회
 */
@Override
public PostInfoDto getPostInfo(Long id) {


    /**
     * Post + MEMBER 조회 -> 쿼리 1번 발생
     *
     * 댓글&대댓글 리스트 조회 -> 쿼리 1번 발생(POST ID로 찾는 것이므로, IN쿼리가 아닌 일반 where문 발생)
     * (댓글과 대댓글 모두 Comment 클래스이므로, JPA는 구분할 방법이 없어서, 당연히 CommentList에 모두 나오는것이 맞다,
     * 가지고 온 것을 가지고 우리가 구분지어주어야 한다.)
     *
     * 댓글 작성자 정보 조회 -> 배치사이즈를 이용했기때문에 쿼리 1번 혹은 N/배치사이즈 만큼 발생
     *
     *
     */
    return new PostInfoDto(postRepository.findWithWriterById(id)
                                          .orElseThrow(() -> new PostException(POST_NOT_POUND)));

}

 

먼저 findWithWriterById를 사용했는데, 이는 제가 만들어준 함수입니다.

 

 

 

 

PostRepository에 추가

public interface PostRepository extends JpaRepository<Post, Long> {


    @EntityGraph(attributePaths = {"writer"})
    Optional<Post> findWithWriterById(Long id);


}

@EntityGraph를 사용하여 Post와 Member를 쿼리 한번에 가져왔습니다.

(EntityGraph는 페치조인을 간편하게 사용할 수 있도록 해주는 어노테이션입니다!)

위를 JPQL로 바꾸면 다음과 같습니다.

"select p from Post p join fetch p.writer w where p.id = :id"

 

 

 

이제 PostInfoDto를 구현하러 가겠습니다.

 

 

 

 

 

 

 

 

 

 

 

PostInfoDto 구현

@Data
public class PostInfoDto {


    private Long postId; //POST의 ID
    private String title;//제목
    private String content;//내용
    private String filePath;//업로드 파일 경로

    private MemberInfoDto writerDto;//작성자에 대한 정보


    private List<CommentInfoDto> commentInfoDtoList;//댓글 정보들




    public PostInfoDto(Post post) {

        this.postId = post.getId();
        this.title = post.getTitle();
        this.content = post.getContent();
        this.filePath = post.getFilePath();


        this.writerDto = new MemberInfoDto(post.getWriter());




        /**
         * 댓글과 대댓글을 그룹짓기
         * post.getCommentList()는 댓글과 대댓글이 모두 조회된다.
         */

        Map<Comment, List<Comment>> commentListMap = post.getCommentList().stream()

                                                     .filter(comment -> comment.getParent() != null)

                                                     .collect(Collectors.groupingBy(Comment::getParent));






        /**
         * 댓글과 대댓글을 통해 CommentInfoDto 생성
         */

        commentInfoDtoList = commentListMap.keySet().stream()

                                            .map(comment -> new CommentInfoDto(comment, commentListMap.get(comment)))
                                            .toList();

    }
}

 

 

 

 

 

 

 

 

 

 

댓글과 대댓글 그룹짓기

댓글과 대댓글을 그룹짓는 부분이 어려우실 것 같아 조금 자세히 보도록 하겠습니다.

Map<Comment, List<Comment>> commentListMap = post.getCommentList().stream()  //(1)

                                             .filter(comment -> comment.getParent() != null) //(2)

                                             .collect(Collectors.groupingBy(Comment::getParent)); //(3)


commentInfoDtoList = commentListMap.keySet().stream() //(4)

                                    .map(comment -> new CommentInfoDto(comment, commentListMap.get(comment)))//(5)
                                    .toList();

 

설명

(1) post의 Comment 리스트를 가져옵니다.

이때 CommentList는 댓글과 대댓글이 모두 섞여있는 상태입니다.

그 이유는 Comment와 Recomment는 단지 parent가 있는지 없는지로만 구분지어지므로, JPA는 댓글과 대댓글을 구분할 방법이 없습니다.

따라서 CommentList를 통해 댓글과 대댓글을 모두 가져오게 되는 것입니다.

(추가로 이때 배치 사이즈를 100으로 설정해 주었기 때문에, 쿼리는 1번 혹은 N/100만큼 발생하게 됩니다.)

 

 

(2) Comment의 parent가 null이 아닌, 즉 댓글이 아닌 대댓글인 것들만 가져옵니다.

 

 

(3) 필터링 된 것들은 모두 대댓글이고, 대댓글의 Parent(댓글)를 통해 그룹핑합니다. 이렇게 되면 Map에는 <댓글, List<해당 댓글에 달린 대댓글>>의 형식으로 그룹핑됩니다.

 

 

(4) 그룹지은 것들 중 keySet , 즉 댓글들을 가지고 옵니다.

 

 

(5) 댓글들을 CommentInfoDto로 변환시켜줍니다. 이때 CommentInfoDto의 생성자로 댓글과 해당 댓글에 달린 대댓글들을 인자로 넣어줍니다.

 

이제 CommentInfoDto를 생성하도록 하겠습니다.

 

 

 

 

 

 

 

 

 

 

 

 

 

 

CommentInfoDto 생성

위치는 다음과 같습니다.

바로 같은 위치에 ReCommentInfoDto도 생성해 주도록 하겠습니다.

package boardexample.myboard.domain.commnet.dto;

import boardexample.myboard.domain.commnet.Comment;
import boardexample.myboard.domain.member.dto.MemberInfoDto;
import lombok.Data;

import java.util.List;

@Data
public class CommentInfoDto {

    private final static String DEFAULT_DELETE_MESSAGE = "삭제된 댓글입니다";

    private Long postId;//댓글이 달린 POST의 ID


    private Long commentId;//해당 댓글의 ID
    private String content;//내용 (삭제되었다면 "삭제된 댓글입니다 출력")
    private boolean isRemoved;//삭제되었는지?


    private MemberInfoDto writerDto;//댓글 작성자에 대한 정보

    private List<ReCommentInfoDto> reCommentListDtoList;//대댓글에 대한 정보들





    /**
     * 삭제되었을 경우 삭제된 댓글입니다 출력
     */

    public CommentInfoDto(Comment comment, List<Comment> reCommentList) {

        this.postId = comment.getPost().getId();
        this.commentId = comment.getId();


        this.content = comment.getContent();

        if(comment.isRemoved()){
            this.content = DEFAULT_DELETE_MESSAGE;
        }

        this.isRemoved = comment.isRemoved();



        this.writerDto = new MemberInfoDto(comment.getWriter());

        this.reCommentListDtoList = reCommentList.stream().map(ReCommentInfoDto::new).toList();

    }
}

 

어려운 것은 없을 것이라 생각하고 넘어가겠습니다.

 

 

 

 

 

 

 

 

 

 

 

 

 

ReCommentInfoDto 생성

package boardexample.myboard.domain.commnet.dto;

import boardexample.myboard.domain.commnet.Comment;
import boardexample.myboard.domain.member.dto.MemberInfoDto;
import lombok.Data;

@Data
public class ReCommentInfoDto {


    private final static String DEFAULT_DELETE_MESSAGE = "삭제된 댓글입니다";

    private Long postId;
    private Long parentId;


    private Long reCommentId;
    private String content;
    private boolean isRemoved;


    private MemberInfoDto writerDto;

    public ReCommentInfoDto(Comment reComment) {
        this.postId = reComment.getPost().getId();
        this.parentId = reComment.getParent().getId();
        this.reCommentId = reComment.getId();
        this.content = reComment.getContent();

        if(reComment.isRemoved()){
            this.content = DEFAULT_DELETE_MESSAGE;
        }

        this.isRemoved = reComment.isRemoved();
        this.writerDto = new MemberInfoDto(reComment.getWriter());
    }
}

 

 

완성했습니다.

이제 테스트 코드를 작성하기 전에 더미 데이터를 입력해 보도록 하겠습니다.

 

 

 

 

 

 

 

 

 

 

 

 

 

더미데이터 입력

위치는 다음과 같습니다.

(이름은.. 뭐라 지을 지 모르겠어서 저렇게 지었습니다)

@RequiredArgsConstructor
@Component
public class InitService {


    private final Init init;


    @PostConstruct
    public void init(){

        init.save();
    }

    @RequiredArgsConstructor
    @Component
    private static class Init{
        private final MemberRepository memberRepository;

        private final PostRepository postRepository;
        private final CommentRepository commentRepository;

        @Transactional
        public void save() {
            PasswordEncoder delegatingPasswordEncoder = PasswordEncoderFactories.createDelegatingPasswordEncoder();


            //== MEMBER 저장 ==//
            memberRepository.save(Member.builder().username("username1").password(delegatingPasswordEncoder.encode("1234567890")).name("USER1").nickName("밥 잘먹는 동훈이1").role(Role.USER).age(22).build());

            memberRepository.save(Member.builder().username("username2").password(delegatingPasswordEncoder.encode("1234567890")).name("USER2").nickName("밥 잘먹는 동훈이2").role(Role.USER).age(22).build());

            memberRepository.save(Member.builder().username("username3").password(delegatingPasswordEncoder.encode("1234567890")).name("USER3").nickName("밥 잘먹는 동훈이3").role(Role.USER).age(22).build());

            Member member = memberRepository.findById(1L).orElse(null);


            for(int i = 0; i<=50; i++ ){
                Post post = Post.builder().title(format("게시글 %s", i)).content(format("내용 %s", i)).build();
                post.confirmWriter(memberRepository.findById((long) (i % 3 + 1)).orElse(null));
                postRepository.save(post);
            }

            for(int i = 1; i<=150; i++ ){
                Comment comment = Comment.builder().content("댓글" + i).build();
                comment.confirmWriter(memberRepository.findById((long) (i % 3 + 1)).orElse(null));

                comment.confirmPost(postRepository.findById(parseLong(valueOf(i%50 + 1))).orElse(null));
                commentRepository.save(comment);
            }


            commentRepository.findAll().stream().forEach(comment -> {

                for(int i = 1; i<=50; i++ ){
                    Comment recomment = Comment.builder().content("대댓글" + i).build();
                    recomment.confirmWriter(memberRepository.findById((long) (i % 3 + 1)).orElse(null));

                    recomment.confirmPost(comment.getPost());
                    recomment.confirmParent(comment);
                    commentRepository.save(recomment);
                }

            });
        }
    }


}

코드를 보시면 의아하신 부분이 하나 있을 것입니다.

왜 굳이 inner 클래스를 생성해서 더미 데이터를 입력해 주었을까요?

 

@PostConstruct는 해당 빈 자체만 생성되었다고 가정하고 호출됩니다. 해당 빈에 관련된 AOP등을 포함한, 전체 스프링 애플리케이션 컨텍스트가 초기화 된 것을 의미하지는 않습니다.
트랜잭션을 처리하는 AOP등은 스프링의 후 처리기(post processer)가 완전히 동작을 끝내서, 스프링 애플리케이션 컨텍스트의 초기화가 완료되어야 적용됩니다.
정리하면 @PostConstruct는 해당빈의 AOP 적용을 보장하지 않습니다.
- 김영한 선생님

따라서 위와 같은 방법으로 우회하여 사용했습니다!

 

 

 

 

이제 애플리케이션을 실행시켜보면 데이터가 잘 들어갈 것입니다!

(이는 테스트코드를 작동해도 계속 작동하기 때문에 애플리케이션을 1회 실행시켜 데이터가 입력되었다면 전체를 주석 처리해서 테스트코드가 실행될 때 데이터가 입력되는 것을 방지해주세요)

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

Post 조회 기능 테스트코드 작성

    @Test
    public void 포스트_조회() throws Exception {
        Member member1 = memberRepository.save(Member.builder().username("username1").password("1234567890").name("USER1").nickName("밥 잘먹는 동훈이1").role(Role.USER).age(22).build());
        Member member2 = memberRepository.save(Member.builder().username("username2").password("1234567890").name("USER1").nickName("밥 잘먹는 동훈이2").role(Role.USER).age(22).build());
        Member member3 = memberRepository.save(Member.builder().username("username3").password("1234567890").name("USER1").nickName("밥 잘먹는 동훈이3").role(Role.USER).age(22).build());
        Member member4 = memberRepository.save(Member.builder().username("username4").password("1234567890").name("USER1").nickName("밥 잘먹는 동훈이4").role(Role.USER).age(22).build());
        Member member5 = memberRepository.save(Member.builder().username("username5").password("1234567890").name("USER1").nickName("밥 잘먹는 동훈이5").role(Role.USER).age(22).build());

        Map<Integer, Long> memberIdMap = new HashMap<>();
        memberIdMap.put(1,member1.getId());
        memberIdMap.put(2,member2.getId());
        memberIdMap.put(3,member3.getId());
        memberIdMap.put(4,member4.getId());
        memberIdMap.put(5,member5.getId());



        /**
         * Post 생성
         */

        Post post = Post.builder().title("게시글").content("내용").build();
        post.confirmWriter(member1);
        postRepository.save(post);
        em.flush();


        /**
         * Comment 생성(댓글)
         */

        final int COMMENT_COUNT = 10;

        for(int i = 1; i<=COMMENT_COUNT; i++ ){
            Comment comment = Comment.builder().content("댓글" + i).build();
            comment.confirmWriter(memberRepository.findById(memberIdMap.get(i % 3 + 1)).orElse(null));
            comment.confirmPost(post);
            commentRepository.save(comment);
        }






        /**
         * ReComment 생성(대댓글)
         */
        final int COMMENT_PER_RECOMMENT_COUNT = 20;
        commentRepository.findAll().stream().forEach(comment -> {

            for(int i = 1; i<=20; i++ ){
                Comment recomment = Comment.builder().content("대댓글" + i).build();
                recomment.confirmWriter(memberRepository.findById(memberIdMap.get(i % 3 + 1)).orElse(null));

                recomment.confirmPost(comment.getPost());
                recomment.confirmParent(comment);
                commentRepository.save(recomment);
            }

        });



        clear();




        //when
        PostInfoDto postInfo = postService.getPostInfo(post.getId());



        //then
        assertThat(postInfo.getPostId()).isEqualTo(post.getId());
        assertThat(postInfo.getContent()).isEqualTo(post.getContent());
        assertThat(postInfo.getWriterDto().getUsername()).isEqualTo(post.getWriter().getUsername());


        int recommentCount = 0;
        for (CommentInfoDto commentInfoDto : postInfo.getCommentInfoDtoList()) {
            recommentCount += commentInfoDto.getReCommentListDtoList().size();
        }

        assertThat(postInfo.getCommentInfoDtoList().size()).isEqualTo(COMMENT_COUNT);
        assertThat(recommentCount).isEqualTo(COMMENT_PER_RECOMMENT_COUNT * COMMENT_COUNT);

    }

 

 

 

 

 

내용이 너무 길기 때문에, 다음 포스팅에 이어서 검색 조건에 따른 게시판 리스트를 조회하는 코드를 작성하도록 하겠습니다.

 

 

 

 

 

 

 

 

전체 코드는 깃허브에서 확인하실 수 있습니다.

 

https://github.com/ShinDongHun1/SpringBoot-Board-API

GitHub - ShinDongHun1/SpringBoot-Board-API

 

 

 

 

 

이상하거나 오류가 나는 부분이 있다면 댓글로 알려주시면 감사하겠습니다.

광고도 한번씩 눌러주시면 감사하겠습니다  :)

 

 

 

 

 

 

 

 

📔 Reference

롬복 빌더 사용시 컬렉션에 Null이 세팅되는 경우

롬복 @Builder 사용시 자바 컬렉션에 null이 세팅되는 경우

 

 

@PostConstruct와 @Transactional의 분리

https://www.inflearn.com/questions/26902

@PostConstruct와 @Transactional 분리 - 인프런 | 질문 & 답변