[JPA] N+1 문제가 발생하는 여러 상황과 해결방법

 

 

 

 

 

🧐 N + 1 문제

N + 1 문제는 연관관계가 설정된 엔티티 사이에서 한 엔티티를 조회하였을 때,
조회된 엔티티의 개수(N 개)만큼 연관된 엔티티를 조회하기 위해 추가적인 쿼리가 발생하는 문제를 의미합니다.

 

즉 N + 1에서, 1은 한 엔티티를 조회하기 위한 쿼리의 개수이며, N은 조회된 엔티티의 개수만큼 연관된 데이터를 조회하기 위한 추가적인 쿼리의 개수를 의미합니다.

 

N + 1보다는, 1 + N이라 부르는 것이 더 이해하기 쉬우며, 정리하면 다음과 같습니다.

엔티티 조회 쿼리(1 번) + 조회된 엔티티의 개수(N 개)만큼 연관된 엔티티를 조회하기 위한 추가 쿼리 (N 번)

 

 

 

 

 

 

 

 

🧐 발생하는 상황

N + 1 문제가 발생하는 상황을 알아보기 위해 게시글과 댓글을 예시로 사용해 보도록 하겠습니다.

 

하나의 게시글에는 여러개의 댓글이 달릴 수 있으며, 이를 코드로 나타내면 다음과 같습니다. (생성자와 Getter는 표시하지 않겠습니다.)

@Entity
public class Post {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String title;
    private String content;

    @OneToMany(mappedBy = "post", cascade = CascadeType.ALL, orphanRemoval = true)
    private List<Comment> comments = new ArrayList<>();

    // 생성자 & Getter 생략

    public Comment writeComment(final String content) {
        Comment comment = new Comment(content, this);
        this.comments.add(comment);
        return comment;
    }
}

@Entity
public class Comment {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String content;

    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "post_id")
    private Post post;

    // 생성자 & Getter 생략
}

 

 

 

이제 N + 1 문제를 발생시키기 위한 테스트코드를 작성해보도록 하겠습니다.

@SpringBootTest
@Transactional
class PostRepositoryTest {

    @Autowired
    private EntityManager em;

    @Autowired
    private PostRepository postRepository;

    @Test
    @DisplayName("N + 1 발생 테스트")
    void test() {
        saveSampleData(); // 10개의 post와, 각각의 post마다 3개씩 댓글 저장
        em.flush();
        em.clear();
        System.out.println("------------ 영속성 컨텍스트 비우기 -----------\n\n");



        System.out.println("------------ POST 전체 조회 요청 ------------");
        List<Post> posts = postRepository.findAll();
        System.out.println("------------ POST 전체 조회 완료. [1번의 쿼리 발생]------------\n\n");




        System.out.println("------------ POST 제목 & 내용 조회 요청 ------------");
        posts.forEach(it -> System.out.println("POST 제목: [%s], POST 내용: [%s]".formatted(it.title(), it.content())));
        System.out.println("------------ POST 제목 & 내용 조회 완료. [추가적인 쿼리 발생하지 않음]------------\n\n");




        System.out.println("------------ POST에 달린 comment 내용 조회 요청 [조회된 POST의 개수(N=10) 만큼 추가적인 쿼리 발생]------------");
        posts.forEach(post -> {
            post.comments().forEach(comment -> {
                System.out.println("POST 제목: [%s], COMMENT 내용: [%s]".formatted(comment.post().title(), comment.content()));
            });
        });
        System.out.println("------------ POST에 달린 comment 내용 조회 완료 ------------\n\n");
    }

    private void saveSampleData() {
        final String postTitleFormat = "[%d] post-title";
        final String postContentFormat = "[%d] post-content";
        final String commentContentFormat = "[%d] comment-content";

        IntStream.rangeClosed(1, 10).forEach(i -> {
            Post post = new Post(format(postTitleFormat, i), format(postContentFormat, i));

            IntStream.rangeClosed(1, 3).forEach(j -> {
                post.writeComment(format(commentContentFormat, j));
            });

            postRepository.save(post);
        });
    }
}

 

로그를 확인해 보면 다음과 같습니다.

 

나머지는 생략하겠습니다.

위와 같이 조회된 post의 개수인 10개만큼의 추가적인 쿼리가 발생한 것을 알 수 있습니다.

 

 

이를 바로 N + 1 문제라 부릅니다.

 

 

 

 

 

 

 

 

 

 

🧐 지연 로딩과 즉시 로딩

N + 1 문제는 지연 로딩(FetchType.LAZY)과 즉시 로딩(FetchType.EAGER) 모든 경우에 발생할 수 있습니다.

 

위의 예제도 즉시 로딩으로 설정한다면, 쿼리가 발생하는 상황만 달라질 뿐, N + 1번의 쿼리가 발생하는 것은 동일합니다.

 

이를 확인하기 위해, Post에서 Comment를 즉시 로딩으로 조회하도록 변경한 뒤, 위의 테스트코드를 그대로 실행시켜보도록 하겠습니다.(출력문만 이해를 돕기 위해 수정하도록 하겠습니다.)

@Entity
public class Post {

    // 필드 생략

    @OneToMany(mappedBy = "post", fetch = FetchType.EAGER, cascade = CascadeType.ALL, orphanRemoval = true)
    private List<Comment> comments = new ArrayList<>();

    // 생성자 & Getter 생략 & 메서드 생략
}

나머지 추가적인 쿼리는 생략한 뒤, 마지막 쿼리에서부터 다시 살펴보도록 하겠습니다.

 

즉 동일한 코드에서 쿼리가 발생하는 시점만 달라질 뿐, 전체적인 쿼리의 수는 동일하다는 것을 알 수 있습니다.

 

 

 

 

이제부터는 위의 경우 말고도, N + 1 문제가 발생할 수 있는 여러 상황과, 상황별 해결방법을 알아보도록 하겠습니다.

이때 모든 경우에 지연 로딩을 사용합니다.

 

참고로 생성자와 Getter 등은 생략하고 작성할 것입니다.

 

 

 

 

 

 

 

 

 

 

 

 

🧐 @OneToOne 관계에서 발생하는 N + 1

fetch join, @EntityGraph로 해결 가능합니다.

@OneToOne 연관관계에서는 주의해야 할 점이 하나 있는데, 연관관계의 주인이 아닌 엔티티를 조회하는 경우, 지연 로딩으로 설정하였더라도 연관된 엔티티를 즉시 로딩으로 조회합니다.

관련해서는 해당 글을 참고해주세요.

 

OneToOne 연관관계 예시로 Member와 Locker를 설정하도록 하겠습니다.

@Entity
public class Locker {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private int number;

    @OneToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "memeber_id")
    private Member member;

    public void register(Member member) {
        this.member = member;
        member.setLocker(this);
    }
}

@Entity
public class Member {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;

    @OneToOne(mappedBy = "member", fetch = FetchType.LAZY)
    private Locker locker;
}

 

👉 N + 1 발생하는 상황

@SpringBootTest
@Transactional
class LockerRepositoryTest {

    @Autowired
    private EntityManager em;

    @Autowired
    private MemberRepository memberRepository;

    @Autowired
    private LockerRepository lockerRepository;


    @BeforeEach
    public void init() {
        IntStream.rangeClosed(1, 3).forEach(i -> {
            Member member = new Member("[%d] MEMBER".formatted(i));
            Locker locker = new Locker(i);
            locker.register(member);
            memberRepository.save(member);
            lockerRepository.save(locker);
        });

        em.flush();
        em.clear();
    }

    @Test
    @DisplayName("OneToOne 주인으로 조회하기")
    void test1() {
        System.out.println("LOCKER 조회");
        List<Locker> lockers = lockerRepository.findAll(); // 쿼리 1번 - 3개의 Locker 조회
        System.out.println("LOCKER 조회 완료\n\n");
        
        lockers.forEach(it -> {
            // 연관관계의 주인이 아닌 엔티티는 무조건 즉시 로딩되기 때문에 쿼리가 추가로 발생한다.
            // (1[회원 조회] + 1[Locker 조회]) * 3[Locker 개수] = 총 6번의 쿼리
            System.out.println("[%d]번 LOCKER 사용하는 회원 이름: [%s]\n".formatted(it.number(), it.member().name()));
        });
    }

    @Test
    @DisplayName("OneToOne 주인 아닌 엔티티로 조회하기 - 지연 로딩으로 설정하더라도 즉시 로딩된다.")
    void test2() {
        System.out.println("MEMBER 조회");
        // 1[회원 전체 조회] + 3[조회된 회원의 수만큼 즉시 로딩으로 인한 쿼리발생] = 총 4번의 쿼리
        List<Member> members = memberRepository.findAll(); 
        System.out.println("MEMBER 조회 완료\n\n");
        
        members.forEach(it -> {
            System.out.println("[%d]번 LOCKER 사용하는 회원 이름: [%s]\n".formatted(it.locker().number(), it.name()));
        });
    }
}

발생하는 쿼리는 주석을 참고해주세요.

 

이제부터 이를 해결해보도록 하겠습니다.

 

 

 

📕 fetch join 사용

다음과 같이 @Query를 통해 fetch join을 사용하여 해결해 보도록 하겠습니다.

public interface MemberRepository extends JpaRepository<Member, Long> {

    @Override
    @Query("select m from Member m join fetch m.locker")
    List<Member> findAll();
}

public interface LockerRepository extends JpaRepository<Locker, Long> {

    @Override
    @Query("select l from Locker l join fetch l.member")
    List<Locker> findAll();
}

 

테스트코드는 동일하게 실행해 보도록 하겠습니다.

 

OneToTOne 주인으로 조회하기

 

OneToTOne 주인 아닌 엔티티로 조회하기

 

위와 같이 N + 1 문제가 해결되어, 한번의 쿼리로 해결된 것을 확인할 수 있습니다.

 

 

 

 

 

 

📙 @EntityGraph 사용

@EntityGraph는 fetch join을 편하게 사용하도록 도와주는 기능입니다.

public interface LockerRepository extends JpaRepository<Locker, Long> {

    //@Query("select l from Locker l join fetch l.member")
    @Override
    @EntityGraph(attributePaths = {"member"})
    List<Locker> findAll();
}

public interface MemberRepository extends JpaRepository<Member, Long> {

    //@Query("select m from Member m join fetch m.locker")
    @Override
    @EntityGraph(attributePaths = {"locker"})
    List<Member> findAll();
}

수행되는 쿼리는 위와 동일하므로 생략하도록 하겠습니다.

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

🧐 @ManyToOne 관계로 연관된 엔티티가 조회되는 경우

fetch join, @EntityGraph로 해결 가능합니다.
쿼리가 한번 더 발생하지만 @BatchSize로도 해결 가능합니다.

post와 comment를 예시로 사용해 보도록 하겠습니다. 마찬가지로 생성자와 Getter등은 생략하여 표시하겠습니다.

@Entity
public class Post {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String title;
    private String content;

    @OneToMany(mappedBy = "post", cascade = CascadeType.ALL, orphanRemoval = true)
    private List<Comment> comments = new ArrayList<>();

    public Comment writeComment(final String content) {
        Comment comment = new Comment(content, this);
        this.comments.add(comment);
        return comment;
    }
}

@Entity
public class Comment {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String content;

    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "post_id")
    private Post post;
}

 

 

 

 

 

👉 N + 1 발생하는 상황

@SpringBootTest
@Transactional
class PostRepositoryTest {

    @Autowired
    private EntityManager em;

    @Autowired
    private CommentRepository commentRepository;

    @Autowired
    private PostRepository postRepository;

    @Test
    @DisplayName("ManyToOne N + 1 발생 테스트")
    void test2() {
        saveSampleData(); // 3개의 post와, 각각의 post마다 2개씩 댓글 저장
        em.flush();
        em.clear();
        System.out.println("------------ 영속성 컨텍스트 비우기 -----------\n\n");



        System.out.println("------------ COMMENT 전체 조회 요청 [1번]------------");
        List<Comment> comments = commentRepository.findAll();
        System.out.println("------------ COMMENT 전체 조회 완료 ------------\n\n");



        System.out.println("------------ COMMENT와 연관된 POST 조회 [ N + 1 문제 발생 ] ------------");
        comments.forEach(comment -> {
            System.out.println("POST 제목: [%s], COMMENT 내용: [%s]".formatted(comment.post().title(), comment.content()));
        });
        System.out.println("------------ COMMENT와 연관된 POST 조회 완료 ------------\n\n");
    }

    private void saveSampleData() {
        final String postTitleFormat = "[%d] post-title";
        final String postContentFormat = "[%d] post-content";
        final String commentContentFormat = "[%d] comment-content";

        IntStream.rangeClosed(1, 3).forEach(i -> {
            Post post = new Post(format(postTitleFormat, i), format(postContentFormat, i));

            IntStream.rangeClosed(1, 2).forEach(j -> {
                post.writeComment(format(commentContentFormat, j));
            });

            postRepository.save(post);
        });
    }
}

 

 

이제부터 이를 해결해 보도록 하겠습니다.

 

 

 

 

 

 

 

📕 fetch join 사용

public interface CommentRepository extends JpaRepository<Comment, Long> {

    @Override
    @Query("select c from Comment c join fetch c.post")
    List<Comment> findAll();
}

 

 

 

 

 

📙 @EntityGraph 사용

public interface CommentRepository extends JpaRepository<Comment, Long> {

    //@Query("select c from Comment c join fetch c.post")
    @Override
    @EntityGraph(attributePaths = {"post"})
    List<Comment> findAll();
}

발생하는 쿼리는 fetch join과 동일합니다.

 

 

 

 

 

 

 

📗 @BatchSize

이는 쿼리 1번으로 해결되지 않고, 2번으로 나누어 해결합니다.

@Entity
@BatchSize(size = 100)
public class Post {
   // 생략
}

위와 같이 설정하거나, 혹은 application.yml 파일에서 다음 속성을 설정하여 적용할 수 있습니다.

spring.jpa.properties.hibernate.default_batch_fetch_size

 

 

batch size를 사용하면 IN 쿼리를 통해 해결하는데, 발생하는 쿼리는 다음과 같습니다.

위와 같이 comment의 id를 IN 절에 넣어 한번에 가져오는 것을 알 수 있습니다.

이때 IN 절에 한번에 들어가는 크기를 BatchSize의 옵션으로 설정할 수 있습니다.

 

 

 

 

 

 

 

 

 

 

 

 

 

 

🧐 @OneToMany 관계로 연관된 엔티티가 조회되는 경우

fetch join, @EntityGraph로 해결 가능합니다.
(그러나 페이징은 진행할 수 없으며, 둘 이상의 컬렉션을 페치 조인하는 데이터가 부정합하게 조회되기 때문에 이를 사용하지 않는 것이 좋습니다.)

OneToMany 관계에서는 @BatchSize 혹은 @Fetch(FetchMode.SUBSELECT)로 해결합니다.

Post와 Comment의 예시에서 Post를 조회하면서 Comment를 함께 조회하는 경우입니다.

 

 

 

👉 N + 1 발생하는 상황

@Test
@DisplayName("OneToMany N + 1 발생 테스트")
void test3() {
    saveSampleData(); // 3개의 post와, 각각의 post마다 2개씩 댓글 저장
    em.flush();
    em.clear();
    System.out.println("------------ 영속성 컨텍스트 비우기 -----------\n\n");


    System.out.println("------------ POST 전체 조회 요청 [1번]------------");
    List<Post> posts = postRepository.findAll();
    System.out.println("------------ POST 전체 조회 완료 ------------\n\n");


    System.out.println("------------ POST와 연관된 COMMENT 조회 [ N + 1 문제 발생 ] ------------");
    posts.forEach(post -> {
        post.comments().forEach(comment -> {
            System.out.println("POST 제목: [%s], COMMENT 내용: [%s]".formatted(post.title(), comment.content()));
        });
    });
    System.out.println("------------ POST와 연관된 COMMENT 조회 완료 ------------\n\n");
}

 

발생하는 쿼리는 다음과 같습니다.

 

 

 

📕 fetch join 사용 - 권장하지 않음

public interface PostRepository extends JpaRepository<Post, Long> {

    @Override
    @Query("select p from Post p join fetch p.comments")
    List<Post> findAll();
}

참고로 이 경우 일대다 조인을 했기 때문에 결과가 늘어나서 중복된 결과가 나타날 수 있었습니다만,

하이버네이트 6 이후부터는 자동으로 distinct를 해주기 때문에 문제가 발생하지 않습니다.

(참고 - https://github.com/hibernate/hibernate-orm/blob/6.0/migration-guide.adoc#distinct)

 

 

 

 

 

 

📙 @EntityGraph 사용 - 권장하지 않음

public interface PostRepository extends JpaRepository<Post, Long> {

    //@Query("select p from Post p join fetch p.comments")
    @Override
    @EntityGraph(attributePaths = {"comments"})
    List<Post> findAll();
}

발생하는 쿼리는 위와 동일합니다.

 

 

 

 

 

 

 

📗 @BatchSize - 권장

spring.jpa.properties.hibernate.default_batch_fetch_size = 100

또는

@Entity
public class Post {

    @BatchSize(size = 100)
    @OneToMany(mappedBy = "post", cascade = CascadeType.ALL, orphanRemoval = true)
    private List<Comment> comments = new ArrayList<>();
}

 

발생하는 쿼리는 다음과 같습니다.

 

 

 

 

 

 

 

 

📘 @Fetch(FetchMode.SUBSELECT)

@Entity
public class Post {

    @Fetch(FetchMode.SUBSELECT)
    @OneToMany(mappedBy = "post", cascade = CascadeType.ALL, orphanRemoval = true)
    private List<Comment> comments = new ArrayList<>();
}

 

발생하는 쿼리는 다음과 같습니다.

서브쿼리를 통해 N + 1 문제를 해결하는 것을 확인할 수 있습니다.

 

 

 

 

 

 

 

 

 

 

 

🧐 N + 1 기본 해결방법 정리

@XToOne의 경우 : fetch join을 통해 해결 (혹은 @EntityGraph)

@XToMany의 경우 : BatchSize를 사용하여 해결 (혹은 @Fetch(FetchMode.SUBSELECT))

 

 

 

 

 

 

 

 

 

🧐 중첩되어 조회되는 경우

위에서 정리한 해결 방법을 통해 복잡하게 중첩되어 있는 상황을 해결해 보도록 하겠습니다.

 

 

회원 + 그룹 -> 게시글 -> 댓글 순으로 한번에 조회되는 상황을 재현해 보도록 하겠습니다.

@Entity
public class Team {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;

    @OneToMany(mappedBy = "team", cascade = CascadeType.ALL, orphanRemoval = true)
    private List<Writer> writers = new ArrayList<>();
}

group은 예약어이므로 테이블 명을 groups로 지었습니다.

@Entity
public class Writer {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;

    private int age;

    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "team_id")
    private Team team;

    @OneToMany(mappedBy = "writer", fetch = FetchType.LAZY, cascade = CascadeType.ALL, orphanRemoval = true)
    private List<Post> posts = new ArrayList<>();
}

@Entity
public class Post {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String title;
    private String content;

    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "writer_id")
    private Writer writer;

    @OneToMany(mappedBy = "post", cascade = CascadeType.ALL, orphanRemoval = true)
    private List<Comment> comments = new ArrayList<>();
    
    public Comment writeComment(final String content) {
        Comment comment = new Comment(content, this);
        this.comments.add(comment);
        return comment;
    }
}

@Entity
public class Comment {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String content;

    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "post_id")
    private Post post;

    protected Comment() {}

    public Comment(final String content, final Post post) {
        this.content = content;
        this.post = post;
    }
}

 

 

 

 

👉 N + 1 발생하는 상황

2개의 Group에 대하여, 각 그룹당 2명의 Writer와, Writer 각각 Post를 2개씩 썼으며, Post당 Comment가 2개씩 달려있는 상황을 생각해 보도록 하겠습니다.

@SpringBootTest
@Transactional
class WriterRepositoryTest {

    @Autowired
    private TeamRepository teamRepository;

    @Autowired
    private WriterRepository writerRepository;

    @Autowired
    private PostRepository postRepository;

    @Autowired
    private CommentRepository commentRepository;

    @Autowired
    private EntityManager em;

    @Test
    @DisplayName("")
    void test() {
        // given
        saveData();

        // when
        System.out.println("--------------WRITER 조회--------------");
        List<Writer> writers = writerRepository.findAll(); // 1번 발생 - 4개 조회
        System.out.println("--------------WRITER 조회 끝---------------\n\n");

        for (Writer writer : writers) {
            for (Post post : writer.posts()) {  // writer당 1번씩, 총 4번 발생 - 각 쿼리마다 2개씩 post 조회
                for (Comment comment : post.comments()) { // post 1개당 1번씩 발생 (총 4(회원 수) * 2(회원별 포스트 수)번 = 8번)
                    // 추가로 Writer당 팀 조회 -> 팀은 총 2개이며, 한번 조회된 것은 영속성 컨텍스트에 남으므로 추가쿼리 발생 X -> 총 2번의 추가쿼리 발생
                    System.out.println("GROUP[%s] - WRITER[%s] - POST[%s] - COMMENT[%s]".formatted(writer.team().name(), writer.name(), post.title(), comment.content()));
                }
            }
        }
    }

    private void saveData() {
        for (int j = 0; j < 2; j++) {
            Team team = new Team("[%d]TEAM".formatted(j));
            teamRepository.save(team);

            for (int i = 0; i < 2; i++) {
                Writer writer = new Writer("[%d]writer".formatted(i), 10, team);
                writerRepository.save(writer);

                for (int i1 = 0; i1 < 2; i1++) {
                    Post post = new Post("[%d]title".formatted(i1), "content", writer);
                    postRepository.save(post);

                    for (int i2 = 0; i2 < 2; i2++) {
                        Comment comment = post.writeComment("[%d] comment".formatted(i2));
                        commentRepository.save(comment);
                    }
                }
            }
        }

        em.flush();
        em.clear();
    }
}

 

 

이 경우 쿼리는 총 1 + 4 + 8 + 2 = 15번 발생합니다.

1번의 쿼리(최초 Writer 전체 조회 시) - 조회되는 Writer는 4명

4번의 쿼리(Writer당 Post 조회 시) - 조회되는 Post는 쿼리당 2개, 총 post의 개수는 8개

8번의 쿼리(4 * 2) - Post당 달려있는 Comment들을 조회하기 위한 쿼리 1번씩 발생. 따라서 조회되는 총 post의 개수와 동일

2번의 쿼리 - Writer가 속한 팀을 조회하기 위함. 한번 조회된 Team은 영속성 컨텍스트에 저장되어 다시 조회하는 경우 추가적인 쿼리가 발생하지 않으므로, 총 2번의 쿼리만 추가적으로 발생함.

 

 

 

 

 

 

🧐 N + 1 해결

우선 @OneToMany 관계의 최적화를 위해 BatchSize를 적용해 보도록 하겠습니다.

위와 같이 총 4번(Writer 1번, Post 1번, Comment 1번, Team 1번)의 쿼리로 줄어든 것을 알 수 있습니다.

 

 

 

이제 @ManyToOne관계, 즉 Writer와 Team에 대한 쿼리를 줄이기 위해 fetch join을 사용해 보도록 하겠습니다.

public interface WriterRepository extends JpaRepository<Writer, Long> {

    @Override
    @Query("select w from Writer w join fetch w.team")
    List<Writer> findAll();
}

 

 

 

다음과 같이 쿼리 3번으로 줄어든 것을 알 수 있습니다.

 

 

 

 

 

 

 

 

 

👉 N + 1 발생하는 상황 - 2

이번엔 반대로 Comment부터 시작해서 Team까지 조회하는 상황을 확인해보도록 하겠습니다.

@Test
@DisplayName("")
void test2() {
    // given
    saveData();

    // when
    System.out.println("-------------- COMMENT 조회--------------");
    List<Comment> comments = commentRepository.findAll();
    //List<Writer> writers = writerRepository.findAll(); // 1번 발생 - 4개 조회
    System.out.println("-------------- COMMENT 조회 끝---------------\n\n");

    //1 + 4 + 8 + 2

    for (Comment comment : comments) {
        System.out.println("GROUP[%s] - WRITER[%s] - POST[%s] - COMMENT[%s]"
                .formatted(
                        comment.post().writer().team().name(),
                        comment.post().writer().name(),
                        comment.post().title(),
                        comment.content()));
    }
}

이 경우에도 아무런 최적화를 하지 않으면 N + 1 문제가 발생하여 15번의 쿼리가 발생합니다.

 

이제 batchsize를 적용하면 아래와 같이 4번으로 쿼리가 줄어듭니다.

 

이때 ManyToOne 관계에 모두 fetch join을 적용하면 다음과 같습니다.

 

public interface CommentRepository extends JpaRepository<Comment, Long> {

    @Override
    @Query("select c from Comment c join fetch c.post p join fetch p.writer w join fetch w.team")
    List<Comment> findAll();
}

 

BatchSize에 상관없이 쿼리 한번으로 모두 조회가 되는 것을 알 수 있습니다.

 

 

이렇듯 최초 조회되는 대상에 따라서도 쿼리의 수가 달라지기 때문에, 상황에 따라 적절히 최적화를 진행해 주시면 될 것 같습니다.