API 개발 고급 - 컬렉션 조회 최적화

• 주문내역에서 추가로 주문한 상품 정보를 추가로 조회하자.
• Order기준으로 컬렉션인 OrderItem 와 Item 이 필요하다.

 

앞선 예제에서는 xxxToOne(OneToOne, ManyToOne)관계만 있었다. 이번에는 컬렉션인 일대다 관계(OneToMany)를 조회하고 최적화 하는 방법을 알아보자.

 

 

 

주문 조회 V1: 엔티티 직접 노출

---

package jpabook.jpashop.api;

import java.util.List;
import jpabook.jpashop.domain.Order;
import jpabook.jpashop.domain.OrderItem;
import jpabook.jpashop.repository.OrderRepository;
import jpabook.jpashop.repository.OrderSearch;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequiredArgsConstructor
public class OrderApiController {

    private final OrderRepository orderRepository;

    /**
     * V1. 엔티티 직접 노출
     * - Hibernate5Module 모듈 등록, LAZY=null 처리
     * - 양방향 관계 문제 발생 -> @JsonIgnore
     */
    @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;
    }
}

• orderItem , item 관계를 직접 초기화하면 Hibernate5Module 설정에 의해 엔티티를 JSON으로 생성한다.
• 양방향 연관관계면 무한 루프에 걸리지 않게 한 곳에 @JsonIgnore 를 추가해야 한다.
• 엔티티를 직접 노출하므로 좋은 방법은 아니다.

 

 

주문 조회 V2: 엔티티를 DTO로 변환

---

package jpabook.jpashop.api;

import jpabook.jpashop.domain.Address;
import jpabook.jpashop.domain.Order;
import jpabook.jpashop.domain.OrderItem;
import jpabook.jpashop.domain.OrderStatus;
import jpabook.jpashop.repository.OrderRepository;
import jpabook.jpashop.repository.OrderSearch;
import lombok.Data;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import java.time.LocalDateTime;
import java.util.List;
import java.util.stream.Collectors;

@RequiredArgsConstructor
@RestController
public class OrderApiController {
    private final OrderRepository orderRepository;

    @GetMapping("/api/v2/orders")
    public List<OrderDto> ordersV2() {
        List<Order> orders = orderRepository.findAllByString(new OrderSearch());
        List<OrderDto> collect = orders.stream()
                .map(o -> new OrderDto(o))
                .collect(Collectors.toList());
        return collect;
    }

    @Data
    static class OrderDto {
        private Long orderId;
        private String name;
        private LocalDateTime orderDate;
        private OrderStatus orderStatus;
        private Address address;
        private List<OrderItemDto> orderItems;

        public OrderDto(Order o) {
            orderId = o.getId();
            name = o.getMember().getName();
            orderDate = o.getOrderDate();
            orderStatus = o.getStatus();
            address = o.getDelivery().getAddress();
            orderItems = o.getOrderItems().stream()
                    .map(orderItem -> new OrderItemDto(orderItem))
                    .collect(Collectors.toList());
        }
    }

    @Data
    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();
        }
    }

}

• (중요) OrderDto 생성자를 잘 살펴보면 OrderItems역시 지연로딩으로 호출해주고 있다. 하지만, OrderItem역시 엔티티이기 때문에 그대로 호출 해주면 안된다. 그렇기 때문에 필요한 필드를 포함하는 OrderItemDto를 만들어서 생성해줘야 한다.
• ValueObject(ex: Address)정도는 엔티티 그대로 조회해도 상관없다. 중요한 것은 선택

 

문제점

• 지연 로딩으로 너무 많은 SQL 실행
• SQL 실행 수 (1 + N + N + N)
  • order 1번
  • member, address N번 (order조회 수 만큼)
  • orderItem N번 (order조회 수 만큼)
  • item N번 (order조회 수 만큼)

※ 참고

지연 로딩은 영속성 컨텍스트에 있으면 영속성 컨텍스트에 있는 엔티티를 사용하고 없으면 SQL을 실행한다. 따라서 같은 영속성 컨텍스트에서 이미 로딩한 회원 엔티티를 추가로 조회하면 SQL을 실행하지 않는다.

 

 

주문 조회 V3: 엔티티를 DTO로 변환 - 페치 조인 최적화

---

Controller API

@GetMapping("/api/v3/orders")
public List<OrderDto> ordersV3() {
    List<Order> allWithItem = orderRepository.findAllWithItem();
    for (Order order : allWithItem) {
        System.out.println("order ref="+order+" order.getId() = " + order.getId());
    }
    List<OrderDto> collect = allWithItem.stream()
            .map(o -> new OrderDto(o))
            .collect(Collectors.toList());
    return collect;

}

Repository Method

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();
}

실행된 쿼리

    select
        order0_.order_id as order_id1_6_0_,
        member1_.member_id as member_i1_4_1_,
        delivery2_.delivery_id as delivery1_2_2_,
        orderitems3_.order_item_id as order_it1_5_3_,
        item4_.item_id as item_id2_3_4_,
        order0_.delivery_id as delivery4_6_0_,
        order0_.member_id as member_i5_6_0_,
        order0_.order_date as order_da2_6_0_,
        order0_.status as status3_6_0_,
        member1_.city as city2_4_1_,
        member1_.street as street3_4_1_,
        member1_.zipcode as zipcode4_4_1_,
        member1_.name as name5_4_1_,
        delivery2_.city as city2_2_2_,
        delivery2_.street as street3_2_2_,
        delivery2_.zipcode as zipcode4_2_2_,
        delivery2_.status as status5_2_2_,
        orderitems3_.count as count2_5_3_,
        orderitems3_.item_id as item_id4_5_3_,
        orderitems3_.order_id as order_id5_5_3_,
        orderitems3_.order_price as order_pr3_5_3_,
        orderitems3_.order_id as order_id5_5_0__,
        orderitems3_.order_item_id as order_it1_5_0__,
        item4_.name as name3_3_4_,
        item4_.price as price4_3_4_,
        item4_.stock_quantity as stock_qu5_3_4_,
        item4_.artist as artist6_3_4_,
        item4_.etc as etc7_3_4_,
        item4_.author as author8_3_4_,
        item4_.isbn as isbn9_3_4_,
        item4_.actor as actor10_3_4_,
        item4_.director as directo11_3_4_,
        item4_.dtype as dtype1_3_4_ 
    from
        orders order0_ 
    inner join
        member member1_ 
            on order0_.member_id=member1_.member_id 
    inner join
        delivery delivery2_ 
            on order0_.delivery_id=delivery2_.delivery_id 
    inner join
        order_item orderitems3_ 
            on order0_.order_id=orderitems3_.order_id 
    inner join
        item item4_ 
            on orderitems3_.item_id=item4_.item_id

distinct 없을 때 문제

DB입장에서 order와 orderItem을 join 할때 중복된 데이터가 포함된다. 그러므로 JPA에서 order와 orderItem을 가져올 때 데이터가 2배가 되어 버린다.

 

즉, DB 입장에서 JOIN을 할 때 일대다(1:N) 관계에서는 N 만큼 데이터양이 뻥튀기 되어버린다. 

 

 

JPQL에 distinct 추가 했을 때 결과

실행된 쿼리

    select
        distinct order0_.order_id as order_id1_6_0_,
        member1_.member_id as member_i1_4_1_,
        delivery2_.delivery_id as delivery1_2_2_,
        orderitems3_.order_item_id as order_it1_5_3_,
        item4_.item_id as item_id2_3_4_,
        order0_.delivery_id as delivery4_6_0_,
        order0_.member_id as member_i5_6_0_,
        order0_.order_date as order_da2_6_0_,
        order0_.status as status3_6_0_,
        member1_.city as city2_4_1_,
        member1_.street as street3_4_1_,
        member1_.zipcode as zipcode4_4_1_,
        member1_.name as name5_4_1_,
        delivery2_.city as city2_2_2_,
        delivery2_.street as street3_2_2_,
        delivery2_.zipcode as zipcode4_2_2_,
        delivery2_.status as status5_2_2_,
        orderitems3_.count as count2_5_3_,
        orderitems3_.item_id as item_id4_5_3_,
        orderitems3_.order_id as order_id5_5_3_,
        orderitems3_.order_price as order_pr3_5_3_,
        orderitems3_.order_id as order_id5_5_0__,
        orderitems3_.order_item_id as order_it1_5_0__,
        item4_.name as name3_3_4_,
        item4_.price as price4_3_4_,
        item4_.stock_quantity as stock_qu5_3_4_,
        item4_.artist as artist6_3_4_,
        item4_.etc as etc7_3_4_,
        item4_.author as author8_3_4_,
        item4_.isbn as isbn9_3_4_,
        item4_.actor as actor10_3_4_,
        item4_.director as directo11_3_4_,
        item4_.dtype as dtype1_3_4_ 
    from
        orders order0_ 
    inner join
        member member1_ 
            on order0_.member_id=member1_.member_id 
    inner join
        delivery delivery2_ 
            on order0_.delivery_id=delivery2_.delivery_id 
    inner join
        order_item orderitems3_ 
            on order0_.order_id=orderitems3_.order_id 
    inner join
        item item4_ 
            on orderitems3_.item_id=item4_.item_id

하지만 DB에 위 쿼리를 실행해보면??

• 여전히 DB 입장에서 결과는 4개의 레코드가 나온다...
• DB 입장에서 distinct는  row 전체 데이터가 똑같아야 중복 제거가 된다. 그러나 위 데이터를 그렇지 못한다.

그렇다면 JPA 입장에서 distinct를 해줬을 때 리스트 결과과 아래와 같이 나오는 이유는 뭘까?

JPA는 distinct가 있으면 영속성 컨텍스트에 같은 @Id 가 있으면 해당 엔티티에 대해 중복을 제거해주는 것이다.

즉, 애플리케이션에는 다 가져와서 중복 엔티티가 있으면 해당 중복을 제거해주고 List에 담아서 반환해준다.

 

 

정리

• 페치 조인으로 인해 SQL이 한 번만 실행된다.
• oneToMany관계일 때 distinct를 사용하지 않으면 row수가 ONE의 갯수가 아닌 Many의 갯수만큼 증가한다. 그 결과 위 코드에서 distinct를 빼면 Order 엔티티의 조회 수도 증가하게 된다.
• JPQL에서 distinct를 사용하게 되면 SQL에 distinct를 추가하고, 더하여 애플리케이션에서 같은 엔티티 중복을 걸러준다. 이로써 컬렉션 페치 조인 때문에 중복 조회 되는것을 막을 수 있다. 하지만....

 

 

단점

• 일대다(1:N) 을 페치 조인 하는 순간 페이징 불가능

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)
        .setFirstResult(1)
        .setMaxResults(100)
        .getResultList();
}

실행된 쿼리

    select
        distinct order0_.order_id as order_id1_6_0_,
        member1_.member_id as member_i1_4_1_,
        delivery2_.delivery_id as delivery1_2_2_,
        orderitems3_.order_item_id as order_it1_5_3_,
        item4_.item_id as item_id2_3_4_,
        order0_.delivery_id as delivery4_6_0_,
        order0_.member_id as member_i5_6_0_,
        order0_.order_date as order_da2_6_0_,
        order0_.status as status3_6_0_,
        member1_.city as city2_4_1_,
        member1_.street as street3_4_1_,
        member1_.zipcode as zipcode4_4_1_,
        member1_.name as name5_4_1_,
        delivery2_.city as city2_2_2_,
        delivery2_.street as street3_2_2_,
        delivery2_.zipcode as zipcode4_2_2_,
        delivery2_.status as status5_2_2_,
        orderitems3_.count as count2_5_3_,
        orderitems3_.item_id as item_id4_5_3_,
        orderitems3_.order_id as order_id5_5_3_,
        orderitems3_.order_price as order_pr3_5_3_,
        orderitems3_.order_id as order_id5_5_0__,
        orderitems3_.order_item_id as order_it1_5_0__,
        item4_.name as name3_3_4_,
        item4_.price as price4_3_4_,
        item4_.stock_quantity as stock_qu5_3_4_,
        item4_.artist as artist6_3_4_,
        item4_.etc as etc7_3_4_,
        item4_.author as author8_3_4_,
        item4_.isbn as isbn9_3_4_,
        item4_.actor as actor10_3_4_,
        item4_.director as directo11_3_4_,
        item4_.dtype as dtype1_3_4_ 
    from
        orders order0_ 
    inner join
        member member1_ 
            on order0_.member_id=member1_.member_id 
    inner join
        delivery delivery2_ 
            on order0_.delivery_id=delivery2_.delivery_id 
    inner join
        order_item orderitems3_ 
            on order0_.order_id=orderitems3_.order_id 
    inner join
        item item4_ 
            on orderitems3_.item_id=item4_.item_id

실행된 쿼리를 보면 페이징을 위한 limit가 보이지 않는다?? 그리고 IDE에서는 다음과 같은 경고가 출력된다.

WARN 을 보면 firstResult/maxResults 가 컬렉션 fetch 조인과 같이 사용됐다고 나온다 그리고 applying in memory 즉, 메모리에서 적용됐다는데 무슨 말일까?

 

이 말은 페치 조인을 사용했는데 페이징 쿼리가 들어가서 메모리에서 페이징 처리를 해버렸다는 뜻이다. 만약 데이터가 1 만건이였다면 1만건의 데이터 모두를 애플리케이션으로 가져오고 메모리에서 페이징 처리를 한다는 위험!! 한 행위이다. (out Of Memory)

 

 

그렇다면 하이버네이트는 왜 이러한 전략을 사용했을까?

위 예시에서 Order에 대해 기대하는 결과는 2건이다. 그런데 DB 입장에서 1 : N 페치 조인 결과는 데이터가 4건이 조회된다. 즉, 1 : N 조인을 하는 순간 Order에 기준 자체가 틀어져버린다.

 

여기서 DB 입장에서 생성된 데이터 4건을 통해 페이징 처리를 한다면 어떤 결과가 나올까??

값을 2건은 끊고 2건만 가져오라고 하면 Order_Id가 11인 2건이 가져와 질수도 있다. 또한 3건을 가져오라고 하면 Order_Id가 4, 11, 11 인 데이터가 조회되면서 결과가 뒤죽박죽 나올 것이다. 

 

이렇게 되면 우리가 원했던 Order에 대한 Size가 정확하게 나오지 않게 되어 버린다. 우리가 원했던 것은 Order가 2건이고 이 Order를 기준으로 페이징을 하고 싶었는데 1:N 조인으로 인해 N을 기준으로 데이터가 뻥튀기 되어버리니깐 DB 입장에선 페이징 자체가 불가능해지는 것이다.

 

즉, DB 입장에선 limit, offset을 하면 Order를 기준으로 페이징이 적용되는 것이 아니라 데이터가 뻥튀기 되어버린 N인 OrderItem을 기준으로 페이징이 되버리는 것이다. 그래서 Order는 중간에서 데이터 개수를 못맞춘다.

 

그래서 어쩔 수 없이 하이버네이트는 1 : N 페치 조인이 들어가 버리면 경고를 내면서 메모리에서 페이징 처리를 하는 것이다!!

※ 참고

컬렉션 페치 조인을 사용하면 페이징이 불가능하다. 하이버네이트는 경고 로그를 남기면서 모든 데이터를 DB에서 읽어오고, 메모리에서 페이징을 해버린다. (매우 위험하다)
그럼, 조회할 데이터가 적을 때는 문제가 되지않지만, 데이터가 커지게되면 out of memory 예외가 발생할수도 있고 몹시 치명적이다.

※ 참고
컬렉션 페치 조인은 1개만 사용할 수 있다. 컬렉션 둘 이상 페치조인을 사용하면 데이터의 정합성이 떨어질 뿐만 아니라 N * N개로 조회되는 중복된 ROW의 수가 기하급수적으로 늘어나게 된다.

 

 

 

주문 조회 V3.1: 엔티티를 DTO로 변환 - 페이징과 한계 돌파

---

페이징과 한계 돌파

• 컬렉션을 페치 조인하면 페이징이 불가능하다.
  • 컬렉션을 페치 조인하면 일대다 조인이 발생하므로 데이터가 예측할 수 없이 증가한다.
  • 일대다에서 일(1)을 기준으로 페이징을 하는 것이 목적이다. 그런데 데이터는 다(N)를 기준으로 row가 생성된다.
  • Order를 기준으로 페이징 하고 싶은데, 다(N)인 OrderItem을 조인하면 OrderItem이 기준이 되어버린다.
  • (더 자세한 내용은 자바 ORM 표준 JPA 프로그래밍 - 페치 조인 한계 참조)
• 이 경우 하이버네이트는 경고 로그를 남기고 모든 DB데이터를 읽어서 메모리에서 페이징을 시도하는데 최악의 경우 장애로 이어질 수 있다.

 

한계 돌파

그러면 페이징 + 컬렉션 엔티티를 함께 조회하려면 어떻게 해야할까?

지금부터 코드도 단순하고, 성능 최적화도 보장하는 매우 강력한 방법을 소개하겠다. 대부분의 페이징 + 컬 렉션 엔티티 조회 문제는 이 방법으로 해결할 수 있다.

 

• 먼저 ToOne(OneToOne, ManyToOne) 관계를 모두 페치조인 한다. ToOne 관계는 row수를 증가시키지 않으므로 페이징 쿼리에 영향을 주지 않는다. => ToOne 관계는 계속 페치조인을 걸어도 문제가 되지 않는다!!
• 컬렉션은 지연 로딩으로 조회한다.
• 지연 로딩 성능 최적화를 위해 hibernate.default_batch_fetch_siez , @BatchSize 를 적용한다.
  • hibernate.default_batch_fetch_size: 글로벌 설정
  • @BatchSize: 개별 최적화
  • 이 옵션을 사용하면 컬렉션이나, 프록시 객체를 한꺼번에 설정한 size만큼 IN쿼리로 조회한다.

OrderRepository에 추가

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();
}

OrderApiController에 추가

/**
 * V3.1 엔티티를 조회해서 DTO로 변환 페이징 고려
 * - ToOne 관계만 우선 모두 페치 조인으로 최적화
 * - 컬렉션 관계는 hibernate.default_batch_fetch_size, @BatchSize로 최적화
 */
@GetMapping("/api/v3.1/orders")
public List<OrderDto> ordersV3_page(
    @RequestParam(value = "offset", defaultValue = "0") int offset,
    @RequestParam(value = "limit", defaultValue = "100") int limit)
{
    // ToOne 관계에 있는 것들만 페치조인하여 가져온다.
    List<Order> orders = orderRepository.findAllWithMemberDelivery(offset, limit);

    for (Order order : orders) {
        System.out.println("order ref = " + order + " id = " + order.getId());
    }

    List<OrderDto> collect = orders.stream()
        .map(o -> new OrderDto(o))
        .collect(Collectors.toList());

    return collect;
}

최적화 옵션

spring:
  jpa:
    properties:
      hibernate:
        default_batch_fetch_size: 1000

• 최적화옵션의 default_batch_fetch_size를 개별로 설정하려면 @BatchSize 를 적용하면 된다.
• 컬렉션은 컬렉션 필드에, 엔티티는 엔티티 클래스에 적용한다.

default_batch_fetch_size는 결국 IN 쿼리를 개수를 몇개로 할것인지를 지정하는 것이다.

예를 들어 총 데이터가 100건이고 default_batch_fetch_size를 10이라고 했을 때 10번 IN 쿼리가 날아가면서 미리 10개의 데이터들을 땡겨온다. 만약 for loop를 계속 돌면서 11번째이면 10개를 땡겨온다.

 

하지만 대부분의 애플리케이션은 이미 DB에서 가져온다고 날린 쿼리를 굳이 짤를 일이 없기 때문에 loop 를 끝까지 돌린다.

 

 

테스트

현재 데이터는 회원 2명(A,B), 주문 건수 2건, 주문 아이템이 4개이다. 

만약 default_batch_fetch_size를 2라고 지정했다면 실행되는 쿼리는 총 다음과 같을 것이다.

IN 쿼리 개수가 2개로 지정됐기 때문에 아래 쿼리가 2번 실행된다!!

장점

• 쿼리 호출 수가 1 + N  → 1 + 1 로 최적화 된다.
• 조인보다 DB 데이터 전송량이 최적화 된다. (Order와 OrderItem을 조인하면 Order가 OrderItem 만큼 중복해서 조회된다. 이 방법은 각각 조회하므로 전송해야할 중복 데이터가 없다.)
• 페치 조인 방식과 비교해서 쿼리 호출 수가 약간 증가하지만, DB 데이터 전송량이 감소한다.
• 컬렉션 페치 조인은 페이징이 불가능 하지만 이 방법은 페이징이 가능하다.

 

 

결론

• ToOne 관계는 페치 조인해도 페이징에 영향을 주지 않는다. 따라서 ToOne 관계는 페치조인으로 쿼리 수를 줄이고 해결하고, 나머지(컬렉션)는 hibernate.default_batch_fetch_size 로 최적화 하자.

※ 참고

default_batch_fetch_size 의 크기는 적당한 사이즈를 골라야 하는데, 100~1000 사이를 선택 하는 것을 권장한다. 이 전략을 SQL IN 절을 사용하는데, 데이터베이스에 따라 IN 절 파라미터를 1000으 로 제한하기도 한다. 1000으로 잡으면 한번에 1000개를 DB에서 애플리케이션에 불러오므로 DB에 순간 부하가 증가할 수 있다. 하지만 애플리케이션은 100이든 1000이든 결국 전체 데이터를 로딩해야 하므로 메모리 사용량이 같다. 1000으로 설정하는 것이 성능상 가장 좋지만, 결국 DB든 애플리케이션이든 순간 부 하를 어디까지 견딜 수 있는지로 결정하면 된다

 

 

 

 

참고 - 스프링 부트 3.1 - 하이버네이트 6.2 변경사항 - array_contains

---

스프링 부트 3.1 부터는 하이버네이트 6.2를 사용한다. 하이버네이트 6.2 부터는 where in 대신에 array_contains 를 사용한다.

 

where in 사용 문법

where item.item_id in(?,?,?,?)

array_contains 사용 문법

where array_contains(?,item.item_id)

참고로 where in 에서 array_contains 를 사용하도록 변경해도 결과는 완전히 동일하다. 그런데 이렇게 변경하는 이유는 성능 최적화 때문이다.

 

 

select ... where item.item_id in(?)

이러한 SQL을 실행할 때 데이터베이스는 SQL 구문을 이해하기 위해 SQL을 파싱하고 분석하는 등 여러가지 복잡한 일을 처리해야 한다. 그래서 성능을 최적화하기 위해 이미 실행된 SQL 구문은 파싱된 결과를 내부에 캐싱하고 있다

 

이렇게 해두면 이후에 같은 모양의 SQL이 실행되어도 이미 파싱된 결과를 그대로 사용해서 성능을 최적화할 수 있다.

※ 참고

여기서 말하는 캐싱은 SQL 구문 자체를 캐싱한다는 뜻이지 SQL의 실행 결과를 캐싱한다는 뜻이 아니다.

SQL 구문 자체를 캐싱하기 때문에 여기서 ? 에 바인딩 되는 데이터는 변경되어도 캐싱된 SQL 결과를 그대로 사용할 수 있다.

 

그런데 where in 쿼리는 동적으로 데이터가 변하는 것을 넘어서 SQL 구문 자체가 변해버리는 문제가 발생한다.

 

다음 예시는 in 에 들어가는 데이터가 개수에 따라서 총 3개의 SQL구문이 생성된다.

where item.item_id in(?)
where item.item_id in(?,?)
where item.item_id in(?,?,?,?)

SQL 입장에서는 ? 로 바인딩 되는 개수 자체가 다르기 때문에 완전히 다른 SQL이다. 따라서 총 3개의 SQL 구문이 만들어지고, 캐싱도 3개를 따로 해야한다. 이렇게 되면 성능 관점에서 좋지않다.

 

array_contains 를 사용하면 이런 문제를 깔끔하게 해결할 수 있다.

 

이 문법은 결과적으로 where in 과 동일하다. array_contains 은 왼쪽에 배열을 넣는데, 배열에 들어있는 숫자가 오른쪽(item_id)에 있다면 참이된다.

 

예시) 다음 둘은 같다.

select ... where array_contains([1,2,3],item.item_id)
select ... item.item_id where in(1,2,3)

 

이 문법은 ? 에 바인딩 되는 것이 딱1개 이다. 배열1개가 들어가는 것이다.

select ... where array_contains(?,item.item_id)

따라서 배열에 들어가는 데이터가 늘어도 SQL 구문 자체가 변하지 않는다. ? 에는 배열 하나만 들어가면 되기 때문이다.

 

이런 방법을 사용하면 앞서 이야기한 동적으로 늘어나는 SQL 구문을 걱정하지 않아도 된다.

결과적으로 데이터가 동적으로 늘어나도 같은 SQL 구문을 그대로 사용해서 성능을 최적화 할 수 있다.

※ 참고

array_contains 에서 default_batch_fetch_size 에 맞추어 배열에 null 값을 추가하는데, 이 부분은 아마도 특정 데이터베이스에 따라서 배열의 데이터 숫자가 같아야 최적화가 되기 때문에 그런 것으로 추정된다.

 

 

 

주문 조회 V4: JPA에서 DTO 직접 조회

---

Controller API

/**
 * V4. JPA에서 DTO로 바로 조회, 컬렉션 N 조회 (1 + N Query) - 페이징 가능
 **/
@GetMapping("/api/v4/orders")
public List<OrderQueryDto> ordersV4(){
    return orderQueryRepository.findOrderQueryDtos();
}

Repository::OrderQueryRepository

package jpabook.jpashop.repository.order.query;

import java.util.List;
import javax.persistence.EntityManager;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Repository;

@Repository
@RequiredArgsConstructor
public class OrderQueryRepository {

    private final EntityManager em;

    /**
     * 컬렉션은 별도로 조회 Query: 루트 1번, 컬렉션 N 번 단건 조회에서 많이 사용하는 방식
     */
    public List<OrderQueryDto> findOrderQueryDtos() {
        //루트 조회(toOne 코드를 모두 한번에 조회)
        List<OrderQueryDto> result = findOrders(); // Query 1번 -> N번

        //루프를 돌면서 컬렉션 추가(추가 쿼리 실행)
        result.forEach(o -> {
            List<OrderItemQueryDto> orderItems = findOrderItems(o.getOrderId()); // Query N번
            o.setOrderItems(orderItems);
        });

        return result;
    }

    /**
     * 1:N 관계(컬렉션)를 제외한 나머지를 한번에 조회
     */
    private List<OrderQueryDto> findOrders() {
        return em.createQuery(
                "select new jpabook.jpashop.repository.order.query.OrderQueryDto(o.id, m.name, o.orderDate, o.status, d.address)" +
                    " from Order o" +
                    " join o.member m" +
                    " join o.delivery d", OrderQueryDto.class)
            .getResultList();
    }

    /**
     * 1:N 관계인 orderItems 조회
     */
    private List<OrderItemQueryDto> findOrderItems(Long orderId) {
        return em.createQuery(
                "select new jpabook.jpashop.repository.order.query.OrderItemQueryDto(oi.order.id, i.name, oi.orderPrice, oi.count)" +
                    " from OrderItem oi" +
                    " join oi.item i" +
                    " where oi.order.id = :orderId", OrderItemQueryDto.class)
            .setParameter("orderId", orderId)
            .getResultList();
    }
}

DTO::OrderQueryDto

package jpabook.jpashop.repository.order.query;

import java.time.LocalDateTime;
import java.util.List;
import jpabook.jpashop.domain.Address;
import jpabook.jpashop.domain.OrderStatus;
import lombok.Data;

@Data
public class OrderQueryDto {

    private Long orderId;
    private String name;
    private LocalDateTime orderDate;
    private OrderStatus orderStatus;
    private Address address;
    private List<OrderItemQueryDto> orderItems;

    public OrderQueryDto(Long orderId, String name, LocalDateTime orderDate, OrderStatus orderStatus, Address address) {
        this.orderId = orderId;
        this.name = name;
        this.orderDate = orderDate;
        this.orderStatus = orderStatus;
        this.address = address;
    }
}

DTO::OrderItemQueryDto

package jpabook.jpashop.repository.order.query;

import com.fasterxml.jackson.annotation.JsonIgnore;
import lombok.Data;

@Data
public class OrderItemQueryDto {

    @JsonIgnore
    private Long orderId;
    private String itemName;
    private int orderPrice;
    private int count;

    public OrderItemQueryDto(Long orderId, String itemName, int orderPrice, int count) {
        this.orderId = orderId;
        this.itemName = itemName;
        this.orderPrice = orderPrice;
        this.count = count;
    }
}

 

 

 

• Query: 루트 1번, 컬렉션 N번 실행
  • 결국, N + 1 문제가 발생

public List<OrderQueryDto> findOrderQueryDtos() {
    List<OrderQueryDto> result = findOrders(); // query 1번 -> N개
    result.forEach(o -> {
        List<OrderItemQueryDto> orderItems = findOrderItems(o.getOrderId()); // Query N번
        o.setOrderItems(orderItems);
    });
    return result;
}

• ToOne(N:1, 1:1)관계들을 먼저 조회하고, ToMany(1:N)관계는 각각 별도로 처리한다.
  • 이런 방식을 선택한 이유는 다음과 같다.
  • ToOne 관계는 조인해도 데이터 Row수가 증가하지 않는다.
  • ToMany(1:N)관계는 조인하면 Row수가 증가한다.
• Row 수가 증가하지 않는 ToOne관계는 조인으로 최적화 하기 쉬우므로 한번에 조회하고, ToMany관계는 최적화 하기 어려우므로 findOrderItems() 와 같은 별도의 메서드로 조회한다.

 

 

 

주문 조회 V5: JPA에서 DTO직접 조회 - 컬렉션 조회 최적화

---

Controller API

/**
 * V5. JPA에서 DTO로 바로 조회, 컬렉션 1 조회 최적화 버전 (1 + 1 Query)
 * - 페이징 가능
 */
@GetMapping("/api/v5/orders")
public List<OrderQueryDto> ordersV5(){
    return orderQueryRepository.findAllByDto_optimization();
}

Repository::OrderQueryRepository

/**
 * 최적화
 * Query: 루트 1번, 컬렉션 1번
 * 데이터를 한꺼번에 처리할 때 많이 사용하는 방식
 *
 */
public List<OrderQueryDto> findAllByDto_optimization() {
    List<OrderQueryDto> result = findOrders();

    Map<Long, List<OrderItemQueryDto>> orderItemMap = findOrderItemMap(toOrderIds(result));

    result.forEach(o -> o.setOrderItems(orderItemMap.get(o.getOrderId())));

    return result;
}

private Map<Long, List<OrderItemQueryDto>> findOrderItemMap(List<Long> orderIds) {
    List<OrderItemQueryDto> orderItems = em.createQuery(
            "select new jpabook.jpashop.repository.order.query.OrderItemQueryDto(oi.order.id, i.name, oi.orderPrice, oi.count)" +
                " from OrderItem oi" +
                " join oi.item i" +
                " where oi.order.id in :orderIds", OrderItemQueryDto.class)
        .setParameter("orderIds", orderIds)
        .getResultList();

    Map<Long, List<OrderItemQueryDto>> orderItemMap = orderItems.stream()
        .collect(Collectors.groupingBy(OrderItemQueryDto -> OrderItemQueryDto.getOrderId()));
    return orderItemMap;
}

private static List<Long> toOrderIds(List<OrderQueryDto> result) {
    return result.stream()
        .map(o -> o.getOrderId())
        .collect(Collectors.toList());
}

• Query: 루트 1번, 컬렉션 1번
• ToOne 관계들을 먼저 조회하고, 여기서 얻은 식별자 orderId로 ToMany 관계인 OrderItem 을 한꺼번에 조회
• MAP을 사용해서 매칭 성능 향상(O(1))
  • V4 에서는 루프를 돌릴 때마다 쿼리를 날렸는데 V5에서는 IN 쿼리를 1번 날리고 메모리에서 Map을 이용하여 값을 매칭해주는 것이다.

 

 

주문 조회 V6: JPA에서 DTO 직접 조회, 플랫 데이터 최적화

---

DTO:: OrderFlatDto

package jpabook.jpashop.repository.order.query;

import java.time.LocalDateTime;
import jpabook.jpashop.domain.Address;
import jpabook.jpashop.domain.OrderStatus;
import lombok.Data;

@Data
public class OrderFlatDto {

    private Long orderId;
    private String name;
    private LocalDateTime orderDate; //주문시간
    private OrderStatus orderStatus;
    private Address address;

    private String itemName;//상품 명
    private int orderPrice; //주문 가격
    private int count; //주문 수량

    public OrderFlatDto(Long orderId, String name, LocalDateTime orderDate, Address address, OrderStatus orderStatus,
        String itemName, int orderPrice, int count) {
        this.orderId = orderId;
        this.name = name;
        this.orderDate = orderDate;
        this.address = address;
        this.orderStatus = orderStatus;
        this.itemName = itemName;
        this.orderPrice = orderPrice;
        this.count = count;
    }
}

 

Repository::OrderQueryRepository

public List<OrderFlatDto> findAllByDto_flat() {
    return em.createQuery(
        "select new jpabook.jpashop.repository.order.query.OrderFlatDto(o.id, m.name, o.orderDate, d.address, o.status, i.name, oi.orderPrice, oi.count)" +
            " from Order o" +
            " join o.member m" +
            " join o.delivery d" +
            " join o.orderItems oi" +
            " join oi.item i", OrderFlatDto.class)
        .getResultList();
}

Controller API V6_1

/**
 * V6. JPA에서 DTO로 바로 조회, 플랫 데이터(1Query) (1 Query) - 페이징 불가능...
 */
@GetMapping("/api/v6/orders")
public List<OrderFlatDto> ordersV6() {
    return orderQueryRepository.findAllByDto_flat();
}

V6_1 로 join 을 통해 한번에 가져온 결과값을 출력해보면 다음과 같은 쿼리 결과가 나온다.

 

V6_1 에서 실행된 쿼리

    select
        order0_.order_id as col_0_0_,
        member1_.name as col_1_0_,
        order0_.order_date as col_2_0_,
        delivery2_.city as col_3_0_,
        delivery2_.street as col_3_1_,
        delivery2_.zipcode as col_3_2_,
        order0_.status as col_4_0_,
        item4_.name as col_5_0_,
        orderitems3_.order_price as col_6_0_,
        orderitems3_.count as col_7_0_ 
    from
        orders order0_ 
    inner join
        member member1_ 
            on order0_.member_id=member1_.member_id 
    inner join
        delivery delivery2_ 
            on order0_.delivery_id=delivery2_.delivery_id 
    inner join
        order_item orderitems3_ 
            on order0_.order_id=orderitems3_.order_id 
    inner join
        item item4_ 
            on orderitems3_.item_id=item4_.item_id

• 이는 중복된 데이터가 존재하므로 올바른 결과는 아니다.
• 이때의 장점은 쿼리가 1개만 실행됐다는 것 뿐이다. 또한 페이징도 가능하다.
• 그러나 Order를 기준으로 페이징하고 싶다는 의도와는 다르게 위와 같이 중복된 결과를 통해서 페이징이 된다.

 

그런데 API 스팩을 V5와 같이 변경하고 싶다면 어떻게 해야할까?

 

노가다 작업...OrderQueryDto 스팩에 맞게 중복을 일일이 제거하면서 억지로 끼워 맞추면 된다.

 

Controller API V6_2

/**
 * V6. JPA에서 DTO로 바로 조회, 플랫 데이터(1Query) (1 Query) - 페이징 불가능...
 */
@GetMapping("/api/v6/orders")
public List<OrderQueryDto> ordersV6() {
    List<OrderFlatDto> flats = orderQueryRepository.findAllByDto_flat();

    return flats.stream()
        .collect(groupingBy(o -> new OrderQueryDto(o.getOrderId(), o.getName(), o.getOrderDate(), o.getOrderStatus(), o.getAddress()),
            mapping(o -> new OrderItemQueryDto(o.getOrderId(), o.getItemName(), o.getOrderPrice(), o.getCount()), toList())
        )).entrySet().stream()
        .map(e -> new OrderQueryDto(e.getKey().getOrderId(), e.getKey().getName(), e.getKey().getOrderDate(), e.getKey().getOrderStatus(), e.getKey().getAddress(), e.getValue()))
        .collect(toList());
}

DTO:: OrderQueryDto

package jpabook.jpashop.repository.order.query;

import java.time.LocalDateTime;
import java.util.List;
import jpabook.jpashop.domain.Address;
import jpabook.jpashop.domain.OrderStatus;
import lombok.Data;
import lombok.EqualsAndHashCode;

@Data
@EqualsAndHashCode(of = "orderId")
public class OrderQueryDto {

    private Long orderId;
    private String name;
    private LocalDateTime orderDate;
    private OrderStatus orderStatus;
    private Address address;
    private List<OrderItemQueryDto> orderItems;

    public OrderQueryDto(Long orderId, String name, LocalDateTime orderDate, OrderStatus orderStatus, Address address) {
        this.orderId = orderId;
        this.name = name;
        this.orderDate = orderDate;
        this.orderStatus = orderStatus;
        this.address = address;
    }

    public OrderQueryDto(Long orderId, String name, LocalDateTime orderDate, OrderStatus orderStatus, Address address,
        List<OrderItemQueryDto> orderItems) {
        this.orderId = orderId;
        this.name = name;
        this.orderDate = orderDate;
        this.orderStatus = orderStatus;
        this.address = address;
        this.orderItems = orderItems;
    }
}

• stream의 groupingBy 을 사용할 땐 그룹화 해줄 기준이 필요하다.
• @EqualsAndHashCode(of = "orderId") 을 통해 orderId 를 기준으로 그룹화하도록 지정하였다.
• 이때 Equals 와 HashCode 를 직접 작성해도 되지만 Lombok에 있는 기능을 사용

 

 

정리

• 해당 코드들을 수행했을 때 실행되는 쿼리(Query)는 1번이다.
• 단점
  • 쿼리는 한 번만 수행되지만 조인으로 인해 DB에서 애플리케이션에 전달하는 데이터에 중복데이터가 추가되기 때문에 V5보다 더 느릴수도 있다.
  • 그루핑 및 객체 매핑 등을 애플리케이션에서 처리하기 때문에 애플리케이션의 추가 작업이 크다.
  • 페이징이 불가능하다.
    → 조회된 내용자체로 페이징은 가능하지만(OrderFlatDto, OrderItem등), Order를 기준으로는 불가능하다. (중복데이터가 있음)

 

 

 

API 개발 고급 정리

---

엔티티 조회

• 엔티티를 조회해서 그대로 반환: V1
• 엔티티 조회 후 DTO로 변환: V2
• 페치 조인으로 쿼리 수 최적화 V3
• 컬렉션 페이징과 한계 돌파: V3.1
  • 컬렉션은 페치 조인시 페이징이 불가능
  • ToOne 관계는 페치 조인으로 쿼리 수 최적화
  • 컬렉션은 페치 조인 대신에 지연 로딩을 유지하고, hibernate.default_batch_fetch_size, @BatchSIze 로 최적화

 

DTO 직접 조회

• JPA에서 DTO를 직접 조회: V4
• 컬렉션 조회 최적화 - 일대다 관계인 컬렉션은 IN절을 활용해서 메모리에 미리 조회해서 최적화: V5
• 플랫 데이터 최적화 - JOIN결과를 그대로 조회 후 애플리케이션에서 원하는 모양으로 직접 변환: V5

 

권장 순서

1. 엔티티 조회 방식으로 우선 접근
   1. 페치조인으로 쿼리 수를 최적화
   2. 컬렉션 최적화
      1. 페이징 필요 hibernate.default_batch_fetch_size , @BatchSize 로 최적화
      2. 페이징 필요 X → 페치 조인 사용
2. 엔티티 조회 방식으로 해결이 안되면 DTO조회 방식 사용
3. DTO조회 방식으로 해결이 안되면 NativeSQL or JdbcTemplate

※ 참고

엔티티 조회 방식은 페치 조인이나, hibernate.default_batch_fetch_size , @BatchSize 같이 코드를 거의 수정하지 않고, 옵션만 약간 변경해서, 다양한 성능 최적화를 시도할 수 있다.
반면에 DTO를 직접 조회하는 방식은 성능을 최적화 하거나 성능 최적화 방식을 변경할 때 많은 코드를 변경해야 한다.

그런데 만약 페치 조인이나 옵션으로 성능 최적화가 안되면 DTO를 직접 쓰면서 성능 최적화하는 방식을 쓸 수도 있다. 하지만 엔티티를 직접 조회하면서 페치 조인이나 옵션으로 성능 최적화가 안되는 상황은 서비스의 트래픽이 많을 가능성이 대부분이다. 그래서 사실 Cache나 다른 외부 요소으로 해결하는 것이 좋다.

결론적으로 페치 조인 방식으로 웬만한 성능이 나온다는 얘기이다.

※ 참고

엔티티를 직접 Caching을 하면 안된다. 기본적으로 엔티티는 영속성 컨텍스트에서 관리되고 상태가 존재한다.
그런데 이때 엔티티가 Cache에 올라가게 되면 영속성 컨텍스트가 관리하는 엔티티가 안지워지는 상황이 발생하게 된다. (꼬인다~~)
그래서 Cache 하는 것은 무조건 DTO로 변환해서 DTO를 캐시해야 한다. 

물론 엔티티를 캐시하는 방법은 하이버네이트의 2차 캐시가 있긴하지만 실무에 적용하기 너무 까다롭다. 

※ 참고

개발자는 성능 최적화와 코드 복잡도 사이에서 줄타기를 해야 한다. 항상 그런 것은 아니지만, 보통 성능 최적화는 단순한 코드를 복잡한 코드로 몰고간다.
엔티티 조회 방식은 JPA가 많은 부분을 최적화 해주기 때문에, 단순한 코드를 유지하면서, 성능을 최적화 할 수 있다.
반면에 DTO 조회 방식은 SQL을 직접 다루는 것과 유사하기 때문에, 둘 사이에 줄타기를 해야 한다.

 

 

DTO조회 방식의 선택지

• DTO로 조회하는 방법도 각각 장단이 있다. V4, V5, V6에서 단순하게 쿼리가 1번 실행된다고 V6이 항상 좋은 방법인 것은 아니다.
• V4는 코드가 단순하다. 특정 주문 한 건만 조회하면 이 방식을 사용해도 성능이 잘 나온다.
  • 예를 들어서 조회한 Order 데이터가 1건이면 OrderItem을 찾기 위한 쿼리도 1번만 실행하면 된다.
  • 하지만 여러 주문을 한꺼번에 가져올 경우는 1 + N 문제가 발생한다.
• V5는 코드가 복잡하다. 여러 주문을 한꺼번에 조회하는 경우에는 V4 대신에 이것을 최적화한 V5방식을 사용해야 한다.
  • 예를 들어서 조회한 Order데이터가 1000건인데,  V4방식을 그대로 사용하면, 쿼리가 총 1+1000번 실행된다. 여기서 1은 Order를 조회한 쿼리고, 1000은 조회된 Order의 row수다. V5방식으로 최적화 하면 쿼리가 총 1+1 번만 실행된다. 상황에 따라 다르겠지만 운영 환경에서 100배 이상의 성능 차이가 날 수 있다.
  • 그리고 특히 페이징이 들어가고 데이터를 10만건 전송해야 한다면 V5를 사용해야 할 것이다. 
• V6는 완전히 다른 접근방식이다. 쿼리 한번으로 최적화 되어서 상당히 좋아보이지만, Order를 기준으로 페이징이 불가능하다. 실무에서는 이정도 데이터면 수백이나, 수천건 단위로 페이징 처리가 꼭 필요하므로, 이 경우 선택하기 어려운 방법이다. 그리고 데이터가 많으면 중복 전송이 증가해서 V5와 비교해서 성능 차이도 미비하다.