[jpa] 컬렉션 조회 최적화 - 1

일대다 관계인 컬렉션을 페치 조인으로 조회할 때,

하나의 정보에 여러개의 컬렉션이 있는 경우 데이터가 늘어나기 때문에 최적화에 어려움이 있다.

 

때문에 하이버네이트 옵션을 줌으로써 해당 문제를 해결할 수 있다.

 

엔티티 직접 노출

@GetMapping("/api/v1/orders")
public List<Order> ordersV1() {
List<Order> all = orderRepository.findAllByString(new OrderSearch());
for (Order order : all) {
order.getMember().getName(); //Lazy 강제 초기화
order.getDelivery().getAddress(); //Lazy 강제 초기환
List<OrderItem> orderItems = order.getOrderItems();
orderItems.stream().forEach(o -> o.getItem().getName()); //Lazy 강제
초기화
}
return all;
}

LAZY로딩이 되어있는 프록시를 강제 초기화시켜주어야한다.

하지만 이 방법은 엔티티를 직접 노출시키기 때문에 좋은 방법이 아니다.

 

엔티티를 DTO로 변환

public List<OrderDto> ordersV2() {
List<Order> orders = orderRepository.findAll();
List<OrderDto> result = orders.stream()
.map(o -> new OrderDto(o))
.collect(toList());
return result;
}

Order 객체를 가져온 뒤 OrderDto 로 변환시킨다.엔티티에 대한 의존을 완전히 끊어야 하기 때문에 단순히 Order에 대한 정보만이 아닌, Item에 대한 정보도 Dto로 변환시킨다.

static class OrderItemDto {
private String itemName;//상품 명
private int orderPrice; //주문 가격
private int count;
//주문 수량
public OrderItemDto(OrderItem orderItem) {
itemName = orderItem.getItem().getName();
orderPrice = orderItem.getOrderPrice();
count = orderItem.getCount();
}
}

하지만 이렇게  되면 여러 개의 여러 번의 지연로딩이 발생할 때마다 쿼리가 발생하기 때문에 1+N 문제가 발생한다.

EX) 주문 1개 ,  주문 정보 N개 , 주문 상품 M개 ->1 + N + M 번의 쿼리 발생

 

 

엔티티를 DTO로 변환- 패치 조인 최적화

public List<Order> findAllWithItem() {
return em.createQuery(
"select distinct o from Order o" +
" join fetch o.member m" +
" join fetch o.delivery d" +
" join fetch o.orderItems oi" +
" join fetch oi.item i", Order.class)
.getResultList();
}

이처럼 페치 조인을 통해 최적화를 해주면 , 쿼리가 한번만 실행됨으로써 기존 1+N 문제를 해결할 수 있다.

JPA 쿼리문의 distinct 는 두 가지 기능을 한다.

1. SQL 에 distinct  추가

2. 같은 엔티티 중복 제거

 

하지만 , 이 코드에서 페이징을 하게 되면 DB가 아닌 메모리에서 페이징을 해버린다.

이것은 메모리 초과(out of memory)를 일으킬 수 있는 매우 위험한 행위임으로 하지 않는 것이 좋다.

 

* 컬렉션 페치 조인은 1개만 사용할 수 있다. 둘 이상 사용하면 데이터 부정합 발생

 

 

엔티티를 DTO로 변환- 페이징 적용

앞선 코드에서 페이징이 안됐던 이유는 일대다 조인에서 데이터가 예측할 수 없이 증가(N)하기 때문이다.하지만 여기서 페이징을 하게되면 페이징 기준이 N 에 맞추어진다.

 

따라서 JPA는 이 경우 메모리에서 페이징 처리를 하는데 이것은 매우 위험하다 !

 

일대다 관계에서 페이징 처리를 하려면 다음과 같이 하면 된다.

1. ToOne 관계는 ROW 수를 증가시키지 않으므로 페치 조인을 한다.

2. 컬렉션은 지연로딩으로 설정한다.

3. hibernate.default_batch_fetch_size , @BatchSize 를 적용한다. (DB에서 미리 불러올 데이터 수)

 

public List<Order> findAllWithMemberDelivery(int offset, int limit) {
return em.createQuery("select o from Order o" +
" join fetch o.member m" +
" join fetch o.delivery d", Order.class)
.setFirstResult(offset)
.setMaxResults(limit)
.getResultList();
}

spring:
jpa:
properties:
hibernate:
default_batch_fetch_size: 1000

ToOne 관계를 한방쿼리로 가져오고 ,  default_batch_fetch_size 를 설정해주면, 설정한 사이즈만큼 컬렉션은 in 쿼리에 담아서 반환한다.

 

따라서 기존 1+ N 이었던 쿼리 수가 1+1 로 줄어든다. 

 

사실 ToOne 관계도 굳이 페치 조인 안해도 상관 없는데 이렇게 하면 쿼리를 줄일 수 있다.

 

만약 조회 할 데이터 수가 2개이고 사이즈를 1로 설정했으면 , 쿼리가 두번 실행된다. (1 X 2)

만약 조회 할 데이터 수가 100개이고 사이즈를 10으로 설정했으면 , 쿼리가 열번 실행된다. (10 X 10)

 

이 방법은 페치 조인으로 했을 때 보다 쿼리는 약간 많이 발생했을지는 몰라도 데이터 최적화가 되어있기 때문에 성능은 더 좋다.

하지만 소규모 데이터일 경우 페치 조인으로 하는 게 더 빠를 수 있다 (상황 by 상황)