의미

• 연관관계가 설정된 엔티티를 조회할 경우 조회된 데이터 갯수 만큼 연관관계의 조회 쿼리가 추가로 발생하는 현상이다.
• 1(조회한 엔티티) + N(연관관계가 걸린 엔티티)

예시

• Cat과 Owner의 다대일 관계

 /**
 * @author Incheol Jung
 */
@Entity
@Getter
@Setter
@NoArgsConstructor
public class Owner {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private int id;
    private String name;

    @OneToMany(mappedBy = "owner", fetch = FetchType.EAGER)
    private Set<Cat> cats = new LinkedHashSet<>();
		
		...
}

@Entity
@Getter
@Setter
@NoArgsConstructor
public class Cat {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private int id;
    private String name;

    @ManyToOne
    private Owner owner;

    public Cat(String name) {
        this.name = name;
    }
}

• 테스트코드
  • 이 경우 Owner 조회 하나당 10건의 Cat 조회 쿼리가 나간다.

@Test
void exampleTest() {
    Set<Cat> cats = new LinkedHashSet<>(); 
    for(int i = 0; i < 10; i++){ // Set당 Cat 객체 10개 추가
        cats.add(new Cat("cat" + i));
    }
    catRepository.saveAll(cats);

    List<Owner> owners = new ArrayList<>();
    for(int i = 0; i < 10; i++){ // 매 Owner에 Cat 10개짜리 Set 추가
        Owner owner = new Owner("owner" + i);
        owner.setCats(cats);
        owners.add(owner);
    }
    ownerRepository.saveAll(owners);

    entityManager.clear();

    System.out.println("-------------------------------------------------------------------------------");
    List<Owner> everyOwners = ownerRepository.findAll();
    assertFalse(everyOwners.isEmpty());
}

해법

• FetchType.LAZY로 설정

  public class Owner {
      @OneToMany(mappedBy = "owner", fetch = FetchType.LAZY)
      private Set<Cat> cats = new LinkedHashSet<>();
  		...
  }
  

  • 프록시 객체를 쓰기 때문에 쿼리가 평소엔 하나만 나가게 된다.
  • 단 Cat 객체에 접근하는 순간 Eager과 똑같아진다.

  List<Owner> everyOwners = ownerRepository.findAll();
  // 이 경우 똑같이 N개의 쿼리가 나가버린다.
  List<String> catNames = everyOwners.stream()
  												.flatMap(it -> it.getCats().stream().map(cat -> cat.getName()))
  												.collect(Collectors.toList());
  assertFalse(catNames.isEmpty());
  

• Fetch join 사용

  @Query("select o from Owner o join fetch o.cats")
  List<Owner> findAllJoinFetch();
  

  • 이 경우 inner join 쿼리가 나가게 된다.
  • 단점으로는
    • FetchType을 Lazy로 해놓아도 무조건 가져오기 때문에 무의미해진다…(내 생각 : 어짜피 가져오는게 의도였으니 상관없지 않나?)
    • 페이징 쿼리가 불가능하다.

• EntityGraph 사용

  @EntityGraph(attributePaths = "cats")
  @Query("select o from Owner o")
  List<Owner> findAllEntityGraph();
  

  • 바로 가져올 필드명 지정 → Eager로 가져온다.
  • 이 경우 outer join이 나간다.
  • Fetch join & EntityGraph 유의사항
    • 카테시안 곱 발생 → Owner의 수만큼 Cat의 중복데이터가 존재할 수 있다.
    • 중복을 제거하기 위해
      • 자료구조를 사용한다(Set은 중복 허용하지 않는다.)
      • JPQL의 distinct를 사용한다.

• @Fetch(FetchMode.SUBSELECT) 사용

  @Entity
  @Getter
  @Setter
  @NoArgsConstructor
  public class Owner {
      @Id
      @GeneratedValue(strategy = GenerationType.IDENTITY)
      private int id;
      private String name;
  
      @Fetch(FetchMode.SUBSELECT)
      @OneToMany(mappedBy = "owner", fetch = FetchType.EAGER)
      private Set<Cat> cats = new LinkedHashSet<>();
  
  }
  

  • 연관관계가 걸린 데이터를 개별로 가져오는게 아니라, 서브쿼리로 하나로 가져온다.
  • 위처럼 즉시로딩으로 설정하면 조회 시점에 가져온다.
  • 지연로딩으로 설정하면 엔티티를 사용하는 시점에 가져온다.

• @BatchSize 사용

  @Entity
  @Getter
  @Setter
  @NoArgsConstructor
  public class Owner {
      @Id
      @GeneratedValue(strategy = GenerationType.IDENTITY)
      private int id;
      private String name;
  
      @BatchSize(size=5)
      @OneToMany(mappedBy = "owner", fetch = FetchType.EAGER)
      private Set<Cat> cats = new LinkedHashSet<>();
  }
  

  • 연관관계가 걸린 데이터들을 in 절을 사용하여 가져온다
    • 위의 경우는 size=5인데 데이터는 10개이므로 in절을 사용하는 쿼리가 2개 나오게 된다.
  • 즉시로딩인 경우
    • → Owner 조회 1번, Cat 5개 조회 2번 : 총 3번
  • 지연로딩인 경우
    • → Owner 조회 시점에 Cat 5개 미리 로딩 1번, 6번째 Cat 접근 시점에 1번 : 총 2번
  • hibernate.default_batch_fetch_size 속성으로 애플리케이션 전체에 적용 가능하다.

  <aside> ➡️ <property name="hibernate.default_batch_fetch_size" value="5" />

  </aside>

• QueryBuilder를 사용한다.

  • QueryDSL, Mybatis, JOOQ, JDBC Template

REFERENCE

https://incheol-jung.gitbook.io/docs/q-and-a/spring/n+1