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

서론

이전까지는 컬렉션이 아닌 ManyToOne이나 OneToOne 관계에 대해서만 조인을 했다.

이런 경우에는 fetch join으로 쉽게 해결할 수 있었다. 그런데 컬렉션 조회라는 건 OneToMany 조회이다.

문제는 DB 입장에서 OneToMany 조인을 하면 데이터가 뻥튀기가 되어버린다.

예를 들어 주문을 하나 했다고 하자. 이 Order는 OrderItem과 OneToMany 관계이다. 

근데 Order에 딸린 OrderItem이 3개라고 한다면 주문을 하나 했는데 하나의 주문에 OrderItem 3개가 딸려 있어 최종결과가 3줄이 되어버린다. 이 경우에는 최적화하기가 어렵다. 

ManyToOne이나 OneToOne 같은 건 fetch join을 하거나 DB 입장에서는 left out join 해서 한 번에 데이터를 다 끌고 와도 성능에 무리가 없는데 컬렉션 조회 같은 경우에는 조회를 하는 순간 DB 입장에서는 데이터가 뻥튀기된다.

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

주문내역에서 추가로 주문한 상품 정보를 추가로 조회하자.

Order 기준으로 컬렉션인 OrderItem과 Item이 필요하다.

앞의 예제에서는 XtoOne(OneToOne, ManyToOne) 관계만 있었다.

이번에는 컬렉션인 일대다 관계(OneToMany)를 조회하고, 최적화하는 방법을 알아보자.

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

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

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

@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(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 order) {
        orderId = order.getId();
        name = order.getMember().getName();
        orderDate = order.getOrderDate();
        orderStatus = order.getStatus();
        address = order.getDelivery().getAddress();
        orderItems = order.getOrderItems().stream()
                .map(orderItem -> new OrderItemDto(orderItem))
                .collect(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();
    } 
}

지연 로딩으로 너무 많은 SQL 실행

SQL 실행 수

• order 1번
• member, address N번(order 조회 수 만큼)
• orderItem N번(order 조회 수 만큼)
• item N번(orderItem 조회 수 만큼)

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

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

OrderApiController에 추가

@GetMapping("/api/v3/orders")
public List<OrderDto>  ordersV3() {
    List<Order> orders = orderRepository.findAllWithItem();
    List<OrderDto> collect = orders.stream()
            .map(o -> new OrderDto(o))
            .collect(toList());
    return collect;
}

OrderRepository에 추가

public List<Order> findAllWithItem() {
    return em.createQuery(
                    "select 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();
}

테이블

JPQL에서 order와 orderItem을 fetch join을 했다.

fetch join은 결국에는 SQL에서 join으로 변환이 된다.

그래서 위 이미지처럼 실제 order와 orderItem을 조인한 결과를 살펴봤다.

맨 아랫부분이 조인 결과인데 앞 부분을 보면 다 order 데이터 부분이다.

근데 보면 order의 1번 데이터가 2개가 되고 2번도 2개가 된다. 즉 order 데이터가 뻥튀기되었다.

문제는 JPA에서 order 데이터를 가지고 올 때도 데이터 뻥튀기가 발생한다.

실제 뻥튀기가 되는지 포스트맨으로 테스트 해보자.

포스트맨 실행결과

[
    {
        "orderId": 1,
        "name": "userA",
        "orderDate": "2024-08-23T16:09:22.838741",
        "orderStatus": "ORDER",
        "address": {
            "city": "서울",
            "street": "1",
            "zipcode": "1111"
        },
        "orderItems": [
            {
                "itemName": "JPA1 BOOK",
                "orderPrice": 10000,
                "count": 1
            },
            {
                "itemName": "JPA2 BOOK",
                "orderPrice": 20000,
                "count": 2
            }
        ]
    },
        {
        "orderId": 1,
        "name": "userA",
        "orderDate": "2024-08-23T16:09:22.838741",
        "orderStatus": "ORDER",
        "address": {
            "city": "서울",
            "street": "1",
            "zipcode": "1111"
        },
        "orderItems": [
            {
                "itemName": "JPA1 BOOK",
                "orderPrice": 10000,
                "count": 1
            },
            {
                "itemName": "JPA2 BOOK",
                "orderPrice": 20000,
                "count": 2
            }
        ]
    },
    {
        "orderId": 2,
        "name": "userB",
        "orderDate": "2024-08-23T16:09:22.852667",
        "orderStatus": "ORDER",
        "address": {
            "city": "진주",
            "street": "2",
            "zipcode": "2222"
        },
        "orderItems": [
            {
                "itemName": "SPRING1 BOOK",
                "orderPrice": 20000,
                "count": 3
            },
            {
                "itemName": "SPRING2 BOOK",
                "orderPrice": 40000,
                "count": 4
            }
        ]
    },
        {
        "orderId": 2,
        "name": "userB",
        "orderDate": "2024-08-23T16:09:22.852667",
        "orderStatus": "ORDER",
        "address": {
            "city": "진주",
            "street": "2",
            "zipcode": "2222"
        },
        "orderItems": [
            {
                "itemName": "SPRING1 BOOK",
                "orderPrice": 20000,
                "count": 3
            },
            {
                "itemName": "SPRING2 BOOK",
                "orderPrice": 40000,
                "count": 4
            }
        ]
    }
]

결과를 보면 데이터가 뻥튀기된 걸 볼 수 있다.

fetch join도 SQL문 입장에서는 그냥 join이다.

그래서 일대다 관계에서 fetch join을 사용하면 일에 속하는 데이터가 다쪽에 맞춰서 늘어나게 된다.(데이터 뻥튀기 발생) 그러면 JPA 입장에서는 일대다 관계에서 fetch join을 사용하여 DB로 쿼리를 보내면 늘어나게 된 데이터를 객체 그래프에 담아야 한다. 결국에는 포스트맨 실행결과처럼 중복된 데이터 결과를 받게 된다.

이러한 문제를 해결하기 위해 JPQL에서 distinct 기능을 제공한다.

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

JPQL에서 제공하는 distinct 기능은 DB의 distinct 기능과 유사하지만 추가로 한 가지 기능이 더 있다.

DB의 distinct는 row가 정말 똑같아야 중복이 제거된다.

그래서 앞서 말한 것처럼 order 부분만 데이터가 중복이 된 거지 뒤에 부분은 중복이 되지 않아 DB에서는 distinct을 적용해도 order의 중복이 제거되지 않는다. 근데 JPA에서의 distinct는 같은 id(PK) 값이면 중복으로 파악하고 중복을 제거한다. 그래서 결과적으로는 애플리케이션으로 뻥튀기된 데이터를 가져와도 id 값이 같으면 중복을 제거한다.

여기서는 order1과 2가 각각 한 번씩 중복돼서 중복을 제거하고 컬렉션에 담긴다.

정리하면 JPA의 distinct 기능은 두 가지 기능이 있다.

• 첫 번째는 DB로 select문을 보낼 때 select문에 distinct 키워드를 추가한다.
• 두 번째는 DB에서 가져온 엔티티가 중복인 경우에 그 중복을 제거하고 컬렉션에 저장한다.

일대다 fetch join 단점은 페이징이 불가능하다.

일대다에서 fetch join을 사용하면 페이징 쿼리가 아예 안 나간다.

실제 페이징이 안되는지 테스트해 보자

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

쿼리 결과

2024-08-23T16:44:05.602+09:00  WARN 68630 --- [nio-8080-exec-1] org.hibernate.orm.query: HHH90003004: firstResult/maxResults specified with collection fetch; applying in memory
Hibernate: 
    select
        distinct o1_0.order_id,
        d1_0.delivery_id,
        d1_0.city,
        d1_0.street,
        ...
        i1_0.director,
        oi1_0.order_price,
        o1_0.status 
    from
        orders o1_0 
    join
        member m1_0 
            on m1_0.member_id=o1_0.member_id 
    join
        delivery d1_0 
            on d1_0.delivery_id=o1_0.delivery_id 
    join
        order_item oi1_0 
            on o1_0.order_id=oi1_0.order_id 
    join
        item i1_0 
            on i1_0.item_id=oi1_0.team_id

setFirstResult(1)과 setMaxResults(100)는 페이징 조건이다.

근데 실행된 쿼리 결과를 보면 limit offset이 보이지 않는다.

그리고 쿼리 위를 보면 HHH90003004: firstResult/maxResults specified with collection fetch; applying in memory라는 warning 로그가 있다. 로그를 읽어보면 firstResult와 maxResults 가 정의가 됐는데 collection fetch join과 같이 정의가 돼서 applying in memory라고 한다.

무슨 말이냐면 fetch join을 써서 애플리케이션으로 가져온 데이터들을 memory에서 페이징 처리 한다는 의미의 경고이다. 만약에 만개의 데이터를 가져오게 되면 만개의 데이터를 애플리케이션으로 가져온 다음에 memory에서 페이징 처리를 하게 된다. 그러면 당연히 out of memory 오류가 발생하면서 장애가 발생한다.

 

JPA가 이렇게 극단적인 처리를 하는 이유가 뭘까?

우리는 order 엔티티의 중복이 제거가 된 상태에서 페이징 처리를 하여 데이터를 가져오고 싶은 거다.

하지만 앞서 말한 것처럼 DB 입장에서는 order 엔티티의 중복이 제거되지 않고 데이터 뻥튀기가 발생한다.

그래서 DB 쪽에서 뻥튀기된 데이터에 페이징 처리를 하니 우리가 예상하는 중복이 제거된 엔티티에 페이징 처리 자체가 불가능하다. 결국에는 일대다 관계에서 fetch join을 사용하면 하이버네이트는 경고를 내고 메모리에서 페이징 처리를 한다.

일대다 fetch join에서는 페이징을 사용하지 말자!!

정리

페치 조인으로 SQL이 1번만 실행됨
distinct를 사용한 이유는 1대다 조인이 있으므로 데이터베이스 row가 증가한다.

그 결과 같은 order 엔티티의 조회 수도 증가하게 된다.

JPA의 distinct는 SQL에 distinct를 추가하고, 더해서 같은 엔티티가 조회되면, 애플리케이션에서 중복을 걸러준다. 이 예에서는 order가 컬렉션 페치 조인 때문에 중복 조회 되는 것을 막아준다.

참고

컬렉션 페치 조인을 사용하면 페이징이 불가능하다.

하이버네이트는 경고 로그를 남기면서 모든 데이터를 DB에서 읽어오고, 메모리에서 페이징 해버린다(매우 위험하다).

참고

컬렉션 페치 조인은 1개만 사용할 수 있다.

일대다에 대한 fetch 조인은 하나만 사용해야 한다.

컬렉션 둘 이상에 페치 조인을 사용하면 안 된다.

컬렉션 둘 이상에 페치 조인을 사용하게 되면 일대다의다가 된다.(1 : n : m)

n x m 이 돼서 데이터가 완전히 뻥튀기가 돼서 데이터가 부정합 하게 조회될 수 있다.

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

페이징과 한계 돌파

컬렉션을 페치 조인하면 페이징이 불가능하다.

• 컬렉션을 페치 조인하면 일대다 조인이 발생하므로 데이터가 예측할 수 없이 증가한다.
• 일다대에서 일(1)을 기준으로 페이징을 하는 것이 목적이다. 그런데 데이터는 다(N)를 기준으로 row가 생성된다.
• Order를 기준으로 페이징 하고 싶은데, 다(N)인 OrderItem을 조인하면 OrderItem이 기준이 되어버린다.

이 경우 하이버네이트는 경고 로그를 남기고 모든 DB 데이터를 읽어서 메모리에서 페이징을 시도한다.

최악의 경우 장애로 이어질 수 있다.

한계 돌파

그러면 페이징 + 컬렉션 엔티티를 함께 조회하려면 어떻게 해야 할까?
지금부터 코드도 단순하고, 성능 최적화도 보장하는 매우 강력한 방법을 소개하겠다.

대부분의 페이징 + 컬렉션 엔티티 조회 문제는 이 방법으로 해결할 수 있다.

• 먼저 XToOne(OneToOne, ManyToOne) 관계를 모두 페치조인 한다.
  • XToOne 관계는 row수를 증가시키지 않으므로 페이징 쿼리에 영향을 주지 않는다.
  • order와 member가 다대일 관계이고 member가 다른 엔티티와 다대일 관계가 있는 경우 이 엔티티에도 fetch join을 걸어도 된다. 데이터 뻥튀기가 되지 않는다.
• 컬렉션은 지연 로딩으로 조회한다.
• 지연 로딩 성능 최적화를 위해 hibernate.default_batch_fetch_size, @BatchSize를 적용한다.
  • hibernate.default_batch_fetch_size: 글로벌 설정
  • @BatchSize: 개별 최적화
  • 이 옵션을 사용하면 컬렉션이나, 프록시 객체를 한꺼번에 설정한 size만큼 IN 절에 담겨 쿼리 하나로 조회한다.
  • 주의할점은 옵션에서 설정한 개수를 넘어가면 추가 쿼리가 발생한다. 예를들어 조회할 데이터는 100개 인데 옵션의 개수가 10이면 IN 절에 10만큼 담기고 쿼리가 전송돼 데이터를 10개만큼 가져오므로 총 10번 쿼리가 발생한다. 

코드로 살펴보자.

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

/**
* 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) {

    List<Order> orders = orderRepository.findAllWithMemberDelivery(offset, limit);
    List<OrderDto> collect = orders.stream()
            .map(o -> new OrderDto(o))
            .collect(toList());
    return collect;
}

최적화 옵션

spring: 
  jpa:
    properties:
      hibernate:
        default_batch_fetch_size: 1000

개별로 설정하려면 @BatchSize를 적용하면 된다. (컬렉션은 컬렉션 필드에, 엔티티는 엔티티 클래스에 적용)

BatchSize 적용 안 한 경우

Hibernate: 
    select
        o1_0.order_id,
        d1_0.delivery_id,
        d1_0.city,
        d1_0.street,
        d1_0.zipcode,
        d1_0.status,
        m1_0.member_id,
        m1_0.city,
        m1_0.street,
        m1_0.zipcode,
        m1_0.name,
        o1_0.order_date,
        o1_0.status 
    from
        orders o1_0 
    join
        member m1_0 
            on m1_0.member_id=o1_0.member_id 
    join
        delivery d1_0 
            on d1_0.delivery_id=o1_0.delivery_id 
    offset
        ? rows 
    fetch
        first ? rows only
Hibernate: 
    select
        oi1_0.order_id,
        oi1_0.order_item_id,
        oi1_0.count,
        oi1_0.team_id,
        oi1_0.order_price 
    from
        order_item oi1_0 
    where
        oi1_0.order_id=?
Hibernate: 
    select
        i1_0.item_id,
        i1_0.dtype,
        i1_0.name,
        i1_0.price,
        i1_0.stock_quantity,
        i1_0.artist,
        i1_0.etc,
        i1_0.author,
        i1_0.isbn,
        i1_0.actor,
        i1_0.director 
    from
        item i1_0 
    where
        i1_0.item_id=?
Hibernate: 
    select
        i1_0.item_id,
        i1_0.dtype,
        i1_0.name,
        i1_0.price,
        i1_0.stock_quantity,
        i1_0.artist,
        i1_0.etc,
        i1_0.author,
        i1_0.isbn,
        i1_0.actor,
        i1_0.director 
    from
        item i1_0 
    where
        i1_0.item_id=?
Hibernate: 
    select
        oi1_0.order_id,
        oi1_0.order_item_id,
        oi1_0.count,
        oi1_0.team_id,
        oi1_0.order_price 
    from
        order_item oi1_0 
    where
        oi1_0.order_id=?
Hibernate: 
    select
        i1_0.item_id,
        i1_0.dtype,
        i1_0.name,
        i1_0.price,
        i1_0.stock_quantity,
        i1_0.artist,
        i1_0.etc,
        i1_0.author,
        i1_0.isbn,
        i1_0.actor,
        i1_0.director 
    from
        item i1_0 
    where
        i1_0.item_id=?
Hibernate: 
    select
        i1_0.item_id,
        i1_0.dtype,
        i1_0.name,
        i1_0.price,
        i1_0.stock_quantity,
        i1_0.artist,
        i1_0.etc,
        i1_0.author,
        i1_0.isbn,
        i1_0.actor,
        i1_0.director 
    from
        item i1_0 
    where
        i1_0.item_id=?

BatchSize 적용한 경우

Hibernate: 
    select
        o1_0.order_id,
        d1_0.delivery_id,
        d1_0.city,
        d1_0.street,
        d1_0.zipcode,
        d1_0.status,
        m1_0.member_id,
        m1_0.city,
        m1_0.street,
        m1_0.zipcode,
        m1_0.name,
        o1_0.order_date,
        o1_0.status 
    from
        orders o1_0 
    join
        member m1_0 
            on m1_0.member_id=o1_0.member_id 
    join
        delivery d1_0 
            on d1_0.delivery_id=o1_0.delivery_id 
    offset
        ? rows 
    fetch
        first ? rows only
Hibernate: 
    select
        oi1_0.order_id,
        oi1_0.order_item_id,
        oi1_0.count,
        oi1_0.team_id,
        oi1_0.order_price 
    from
        order_item oi1_0 
    where
        oi1_0.order_id in (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
Hibernate: 
    select
        i1_0.item_id,
        i1_0.dtype,
        i1_0.name,
        i1_0.price,
        i1_0.stock_quantity,
        i1_0.artist,
        i1_0.etc,
        i1_0.author,
        i1_0.isbn,
        i1_0.actor,
        i1_0.director 
    from
        item i1_0 
    where
        i1_0.item_id in (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)

BatchSize를 적용 하든 안 하든 member와 delivery는 fetch join으로 한 번에 가져온다.

BatchSize를 적용 안하면 컬렉션 조인 같은 경우는 N + 1 문제로 추가 쿼리가 발생할 수 있다.

BatchSize를 적용하면 N + 1 문제로 발생했던 추가 쿼리들 대신 BatchSize에서 설정한 개수만큼 IN 쪽에 조회할 엔티티의 id가 담긴 IN 쿼리가 발생해 쿼리를 줄일 수 있다.

예를 들어 order에 딸린 orderItem이 2개고 각 orderItem에 딸린 item이 2개라고 하자.

그러면 원래는 N + 1 문제로 인해 orderItem에 대한 select 쿼리 2번 item에 대한 select 쿼리가 4번 나가야 한다.

하지만 BatchSize를 설정하면 조회할 orderItem의 id 값들을 뽑아 in 쿼리에 담아 한번만 보낸다.

마찬가지로 item 역시도 조회할 item의 id 값들을 뽑아 in 쿼리에 담아 한번만 보낸다.

장점

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

결론

XToOne 관계는 페치 조인해도 페이징에 영향을 주지 않는다.

따라서 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 직접 조회

@Repository
@RequiredArgsConstructor
public class OrderQueryRepository {

    private final EntityManager em;

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

        //루프를 돌면서 컬렉션 추가(추가 쿼리 실행)
        result.forEach(o -> {
            List<OrderItemQueryDto> orderItems = findOrderItems(o.getOrderId());
            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();
    }
}

Query는 루트 1번, 컬렉션 N번 실행된다.
ToOne(N:1, 1:1) 관계들을 먼저 조회하고, ToMany(1:N) 관계는 각각 별도로 처리한다.

• 이런 방식을 선택한 이유는 다음과 같다.
• ToOne 관계는 조인해도 데이터 row 수가 증가하지 않는다.
• ToMany(1:N) 관계는 조인하면 row 수가 증가한다.

row 수가 증가하지 않는 ToOne 관계는 조인으로 최적화하기 쉬우므로 한 번에 조회하고, ToMany 관계는 최적화하기 어려우므로 findOrderItems() 같은 별도의 메서드로 조회한다.

주의

DTO로 직접 조회하는 경우에는 default_batch_fetch_size 옵션이 직접적으로 적용되지 않는다.

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

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

    //orderItem 컬렉션을 MAP 한방에 조회
    Map<Long, List<OrderItemQueryDto>> orderItemMap = findOrderItemMap(toOrderIds(result));

    //루프를 돌면서 컬렉션 추가(추가 쿼리 실행X)
    result.forEach(o -> o.setOrderItems(orderItemMap.get(o.getOrderId())));
    return result;
}

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

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

    return orderItems.stream()
            .collect(Collectors.groupingBy(orderItemQueryDto -> orderItemQueryDto.getOrderId()));
}

Query는 루트 1번, 컬렉션 1번 총 두 번 호출된다.
ToOne 관계들을 먼저 조회하고, 여기서 얻은 식별자 orderId로 ToMany 관계인 OrderItem을 한꺼번에 조회한다.
MAP을 사용해서 매칭 성능 향상(O(1))

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

DB에서 한방에 다 가져온다.

Order랑 OrderItem 조인하고 OrderItem이랑 Item 조인해서 한방에 가져온다.

그래서 SQL 조인의 결과를 그대로 가져올 수 있도록 데이터 구조를 맞춰야 된다.

OrderApiController에 추가

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

OrderQueryDto에 생성자 추가

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

OrderFlatDto

@Data
public class OrderFlatDto {
    private Long orderId;
    private String name;
    private LocalDateTime orderDate; //주문시간
    private Address address;
    private OrderStatus orderStatus;
    private String itemName;//상품 명
    private int orderPrice; //주문 가격
    private int count; //주문 수량

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

OrderQueryRepository에 추가

public List<OrderFlatDto> findAllByDto_flat() {
    return em.createQuery(
            "select new jpabook.jpashop.repository.order.query.OrderFlatDto(o.id, m.name, o.orderDate, o.status, d.address, 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();
}

Query는 1번 발생한다.

단점

• 쿼리는 한번이지만 조인으로 인해 DB에서 애플리케이션에 전달하는 데이터에 중복 데이터가 추가되므로 상황에 따라 V5 보다 더 느릴 수도 있다.
• 애플리케이션에서 추가 작업이 크다.
• 페이징 불가능

API 개발 고급 정리

정리

지금까지 크게 두 가지에 대해서 배웠다.

JPA 레포지토리를 통해서 엔티티로 조회 또는 DTO로 직접 조회

엔티티 조회

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

DTO 직접 조회

• JPA에서 DTO를 직접 조회: V4
• 컬렉션 조회 최적화 - 일대다 관계인 컬렉션은 IN 절을 활용해서 메모리에 미리 조회해서 최적화: V5
  • JPA에서 DTO를 직접 조회해도 컬렉션 데이터를 줘야 할 때는 일대다가 된다.
  • 그래서 데이터가 뻥튀기 돼서 조회된다.
  • 이러한 부분을 해결하기 위한 방식이 V5다.
  • IN 절을 사용해서 메모리에 미리 다 로딩해 가지고 루프를 돌리면서 맞추는 방식이다.
• 플랫 데이터 최적화 - JOIN 결과를 그대로 조회 후 애플리케이션에서 원하는 모양으로 직접 변환: V6
  • DB 조인 결과를 일대다가 있던 없던 메모리에 다 올린다.
  • 그다음에 애플리케이션에서 발라내서 원하는 모양으로 바꾸는 게 V6 방식이다. 

권장 순서

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

엔티티 조회 방식을 권장하는 이유

엔티티 조회 방식은 페치 조인이나, hibernate.default_batch_fetch_size, @BatchSize같이 코드를 거의 수정하지 않고, 옵션만 약간 변경해서, 다양한 성능 최적화를 시도할 수 있다. 반면에 DTO를 직접 조회하는 방식은 성능을 최적화하거나 성능 최적화 방식을 변경할 때 많은 코드를 변경해야 한다. 그리고 페치 조인이나 BatchSize 옵션으로 해결이 안 되면 트래픽이 엄청 많다는 소리다. 그러면 캐시를 쓰는 식으로 문제를 해결해야지 DTO로 직접 조회한다고 해결이 될까 하는 의문이 있다.

참고

엔티티는 직접 캐싱을 하면 안 된다.

엔티티는 영속성 컨텍스트에서 관리되기 때문에 캐시에 잘못 올라가면 애매하게 꼬일 수가 있다.

그래서 캐싱하는 거는 무조건 DTO로 변환해서 DTO를 캐시해야 한다.

참고

개발자는 성능 최적화와 코드 복잡도 사이에서 줄타기를 해야 한다.

항상 그런 것은 아니지만, 보통 성능 최적화는 단순한 코드를 복잡한 코드로 몰고 간다.

엔티티 조회 방식은 JPA가 많은 부분을 최적화해주기 때문에, 단순한 코드를 유지하면서, 성능을 최적화할 수 있다.

반면에 DTO 조회 방식은 SQL을 직접 다루는 것과 유사하기 때문에, 둘 사이에 줄타기를 해야 한다.

 

DTO 조회 방식의 선택지

DTO로 조회하는 방법도 각각 장단이 있다.

V4, V5, V6에서 단순하게 쿼리가 1번 실행된다고 V6이 항상 좋은 방법인 것은 아니다.

V4는 코드가 단순하다.

• 특정 주문 한건만 조회하면 이 방식을 사용해도 성능이 잘 나온다.
• 예를 들어서 조회한 Order 데이터가 1건이면 OrderItem을 찾기 위한 쿼리도 1번만 실행하면 된다.
• 단점은 Order 데이터가 복수개면 루프를 돌면서 orderItem에 대한 select문이 1번씩 발생한다.

V5는 코드가 복잡하다.

• 여러 주문을 한꺼번에 조회하는 경우에는 V4 대신에 이것을 최적화한 V5 방식을 사용해야 한다.
• 예를 들어서 조회한 Order 데이터가 1000건인데, V4 방식을 그대로 사용하면, 쿼리가 총 1 + 1000번 실행된다.
• 여기서 1은 Order를 조회한 쿼리고, 1000은 조회된 Order의 row 수다.
• V5 방식은 1000건의 Order 데이터에서 id 값을 뽑아 IN 절에 담아서 보내 한 번에 가져온다.
• 한 번에 가져온 다음 메모리에 올려두고 거기서 재조립을 했다.
• 그래서 V5 방식으로 최적화하면 쿼리가 총 1 + 1번만 실행된다.
• 상황에 따라 다르겠지만 운영 환경에서 100배 이상의 성능 차이가 날 수 있다.

V6는 완전히 다른 접근방식이다.

• 일대다 관계로 인해 데이터가 뻥튀기가 되든 JOIN으로 한 번에 가져온다.
• 쿼리 한 번으로 최적화되어서 상당히 좋아 보이지만, Order를 기준으로 페이징이 불가능하다.
• 실무에서는 이 정도 데이터면 수백이나, 수천 건 단위로 페이징 처리가 꼭 필요하므로, 이 경우 선택 하기 어려운 방법이다.
• 그리고 데이터가 많으면 중복 전송이 증가해서 V5와 비교해서 성능 차이도 미비하다.