[스프링 부트와 JPA 활용2] (3) API 개발 고급 - 컬렉션 조회 최적화 & 페이징과 한계 돌파

실무에서 너무 성능이 안 나와서 튜닝을 해야 할 경우, 코드를 확인해 보면 대부분 아래에 나열해 둔 문제가 자주 발생한다고 한다.

• 지연 로딩과 조회 성능 최적화
• 컬렉션 조회 최적화
• 페이징과 한계 돌파
• OSIV와 성능 최적화

등록 및 수정에선 거의 문제가 발생하지 않고, 90% 정도 조회할 때 성능 문제가 발생한다. 따라서 조회용 샘플 데이터를 입력한 뒤 각 문제에 맞춰 API 성능을 최적화하는 방법을 학습한다.

 

이번 섹션에선 주문 내역에서 추가로 주문한 상품 정보를 추가로 조회하는 API를 만든다. Order 기준으로 컬렉션인 OrderItem과 Item이 필요하다.

이전 섹션에서는 xToOne 관계만 있었다. 이번에는 컬렉션인 일대다 관계(OneToMany)를 조회하고, 최적화하는 방법을 학습한다.

 

참고
이전 섹션과 비슷한 내용은 생략했다.

 

---

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

DTO 안에서도 엔티티 노출 X

DTO 안에 엔티티나 엔티티를 감싼 컬렉션이 들어가면 안 된다. 엔티티를 그대로 노출시키지 말아야 한다는 뜻이다. 따라서 OrderDto 안에 OrderItem 리스트 대신 OrderItemDto가 들어가도록 구현해야 한다.

@RestController
@RequiredArgsConstructor
public class OrderApiController {

    ...

    @Data
    static class OrderDto {
        private Long orderId;
        private String name;
        private LocalDateTime orderDate;
        private OrderStatus orderStatus;
        private Address address;
//        private List<OrderItem> orderItems; // 엔티티를 노출시키지 말자
        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(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();
        }
    }
}

 

---

💫일대다 관계에서의 페치 조인

일대다(1:N) 관계에서 '일' 쪽을 기준으로 조인을 진행해도, DB 입장에선 쿼리의 결과가 N행으로 증가한다.

• 예를 들어 1번 회원이 책 A와 B를 주문하고, 2번 회원이 책 C와 D를 주문했다고 해보자. Order엔 2개의 행(회원1, 2 각각 주문)이 존재하고, OrderItem(책 A, B, C, D)엔 4개의 행이 존재한다. 이때 일대다 관계인 Order와 OrderItem를 조인하면 쿼리 결과는 4개의 행(M1&A / M1&B / M2&C / M2&D)으로 늘어나게 된다.
• 애플리케이션에서 하이버네이트가 쿼리 결과를 받으면 그대로 전달하는 것 외엔 할 수 있는 게 없다.

@RestController
@RequiredArgsConstructor
public class OrderApiController {

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

///

@Repository
@RequiredArgsConstructor
public class OrderRepository {
    
    ...
    
    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();
    }
}

 

컬렉션 페치 조인을 사용하면 페이징(setFirstResult(), setMaxResults())이 불가능하다는 단점이 있다. 페이징 쿼리가 아예 나가지 않는다.

• 하이버네이트는 경고 로그를 남기면서 모든 데이터를 DB에서 읽어오고, 메모리에서 페이징 해버린다. 이런 동작 방식은 메모리 자원을 모두 써버릴 수 있기 때문에 매우 위험하다.
  • QueryTranslatorImpl: firstResult/maxResults specified with collection fetch; applying in memory!
• 또, N개의 행으로 늘어난 쿼리 결과에 대해 페이징을 진행하기 때문에 setFirstResult()와 setMaxResults()로 설정한 대로 페이징이 동작하지 않는다는 문제가 생길 수 있다.
• 참고로, 컬렉션 페치 조인은 1개만 사용할 수 있다. 컬렉션 둘 이상에 페치 조인을 사용하면 데이터가 부정합하게 조회될 수 있기 때문에 사용하면 안 된다.

 

참고
하이버네이트6부터는 DISTINCT 명령어를 사용하지 않아도 애플리케이션에서 중복 제거가 자동으로 적용된다. 따라서 결과가 2번 출력되지 않는다.

Starting with Hibernate ORM 6 it is no longer necessary to use distinct in JPQL and HQL to filter out the same parent entity references when join fetching a child collection. The returning duplicates of entities are now always filtered by Hibernate.

 

참고
💫JPQL 페치 조인에 대한 자세한 정보는 아래 글을 참고하자.

[자바 ORM 표준 JPA 프로그래밍 - 기본편] (10) 객체지향 쿼리 언어2 - 중급 문법

 

---

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

페이징과 한계 돌파

위에서 말했듯이 컬렉션을 페치 조인하면 페이징이 불가능하다.

• 컬렉션을 페치 조인하면 일대다 조인이 발생하므로 데이터가 예측할 수 없이 증가한다.
  • 일대다에서 '일' 쪽을 기준으로 페이징을 하는 것이 목적이다. 그런데 데이터는 '다' 쪽을 기준으로 행(row)이 생성된다.
  • Order를 기준으로 페이징을 하고 싶은데, '다' 쪽인 OrderItem을 조인하면 OrderItem이 기준이 돼버린다.
• 이 경우 하이버네이트는 경고 로그를 남기고 모든 DB 데이터를 읽어서 메모리에서 페이징을 시도한다. 최악의 경우 장애로 이어질 수 있다.

 

 

그러면 페이징 + 컬렉션 엔티티를 함께 조회하려면 어떻게 해야 할까? 대부분의 페이징 + 컬렉션 엔티티 조회 문제는 아래 방법으로 해결할 수 있다.

• 먼저, xToOne 관계를 모두 페치 조인한다. xToOne 관계는 row 수를 증가시키지 않으므로 페이징 쿼리에 영향을 주지 않는다.
  • ex. Order에서 Member와 Delivery
• 컬렉션은 페치 조인을 사용하지 않고 지연 로딩으로 조회한다.
  • ex. Order에서 OrderItem → 지연 로딩으로 인한 N + 1 문제 최적화 필요
• 아래 옵션이나 애노테이션을 적용하지 않고, 위에서 말한 방법을 쭉 적용하면 쿼리가 총 6번 발생한다.
  • Order에 Member와 Delivery 페치 조인 → 쿼리 1번
  • 지연 로딩으로 설정해 둔 OrderItem 조회 → 쿼리 1번
  • OrderItem마다 갖고 있는 Item 개수 2개 → 쿼리 4번
• 이후, 지연 로딩 성능 최적화를 위해 hibernate.default_batch_fetch_size 옵션이나 @BatchSize 애노테이션을 적용한다. 이 옵션을 사용하면 컬렉션이나 프록시 객체를 한꺼번에 설정한 size만큼 array_contains 쿼리로 조회한다.
  • 글로벌 설정: hibernate.default_batch_fetch_size
    • 이 옵션은 거의 항상 켜두는 게 낫다.
  • 개별 최적화: @BatchSize
    
    • 컬렉션은 컬렉션 필드에, 엔티티는 엔티티 클래스에 적용

spring:
  jpa:
    properties:
      hibernate:
        default_batch_fetch_size: 1000

 

 

위의 default_batch_fetch_size 옵션이나 @BatchSize을 적용하면,

• 쿼리 호출 수가 1 + N에서 1 + 1로 최적화된다.
  • 위에선 6번(1 + 1 + 2 + 2) 날리던 쿼리가 3번(1 + 1 + 1)으로 줄어든다.
    • Order에 Member와 Delivery 페치 조인 → 쿼리 1번
    • OrderItem을 array_contains를 사용해 ORDER_ID에 맞는 것만 가져 옴 → 쿼리 1번
    • Item을 array_contains를 사용해 ORDERITEM_ID에 맞는 것만 가져 옴 → 쿼리 1번
• 페치 조인 방식(쿼리 1번)과 비교하면 쿼리 호출 수가 약간 증가하지만, DB 데이터 전송량이 감소한다.
  • 즉, Order와 OrderItem을 조인하는 것보다 DB 데이터 전송량도 최적화된다.
  • Order와 OrderItem을 조인하면 Order가 OrderItem만큼 중복해서 조회된다. 그러나 이 방법을 사용하면 각각 연관된 것만 조회하기 때문에 전송해야 할 중복 데이터가 없다.
• 컬렉션 페치 조인은 페이징이 불가능하지만, 이 방법을 사용하면 페이징이 가능하다.

@Repository
@RequiredArgsConstructor
public class 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();
    }
}

//

@RestController
@RequiredArgsConstructor
public class OrderApiController {

    ...
    
    @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> result = orders.stream()
            .map(o -> new OrderDto(o))
            .collect(Collectors.toList());
        return result;
    }
}

 

참고
페이징이 필요 없고 중복 데이터가 적다면 데이터를 페치 조인으로 한 번에 가져오는 게 성능이 더 좋다.

 

결론
xToOne 관계는 페치 조인해도 페이징에 영향을 주지 않는다. 따라서 xToOne 관계는 페치 조인으로 쿼리 수를 줄이고, 나머지는 hibernate.default_batch_fetch_size 옵션이나 @BatchSize를 사용해 최적화하자.

 

---

하이버네이트 6.2 변경사항 - array_contains

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

- Out of Memory가 발생할 확률은 100으로 설정하든 1000으로 설정하든 비슷하다.
- default_batch_fetch_size = IN 쿼리를 날려 데이터를 한꺼번에 가져올 데이터 개수!

 

 

스프링 부트 3.1부터는 하이버네이트 6.2를 사용하는데, where in 대신 array_contains를 사용한다. 참고로 where in에서 array_contains를 사용하도록 변경해도 결과는 완전히 동일하다. 이렇게 변경된 이유는 성능 최적화 때문이다.

# where in
WHERE ITEM.ITEM_ID IN(?, ?, ?, ?)

# array_contains
WHERE ARRAY_CONTAINS(?, ITEM.ITEM_ID)

 

 

아래 예시를 보면서 자세히 알아보자. 아래 SQL을 실행할 때 DB는 SQL 구문을 이해하기 위해 SQL을 파싱하고 분석하는 등 여러 가지 복잡한 일을 처리한다. 이때 성능을 최적화하기 위해 이미 실행된 SQL 구문은 파싱된 결과를 내부에 캐싱하고 있다. 이렇게 해두면 이후에 같은 모양의 SQL이 실행돼도 이미 파싱된 결과를 그대로 사용해서 성능을 최적화할 수 있다.

• 참고로 여기서 말하는 캐싱은 SQL 구문 자체를 캐싱한다는 뜻이지 SQL 실행 결과를 캐싱한다는 뜻이 아니다.
• SQL 구문 자체를 캐싱하기 때문에 여기서 ?에 바인딩되는 데이터가 변경돼도 캐싱된 SQL 결과를 그대로 사용할 수 있다.

SELECT ... WHERE ITEM.ITEM_ID IN(?)

• 그런데 where in 쿼리는 동적으로 데이터가 변하는 것을 넘어서 SQL 구문 자체가 변해버리는 문제가 발생한다. 아래 예시는 in에 들어가는 데이터 숫자에 따라 총 3개의 SQL 구문이 생성된다.
• SQL 입장에서는 ?로 바인딩되는 숫자 자체가 다르기 때문에 완전히 다른 SQL로 본다. 따라서 총 3개의 SQL 구문이 만들어지고, 캐싱도 3개를 따로 해야 하기 때문에 성능 관점에서 좋지 않다.

WHERE ITEM.ITEM_ID IN(?)
WHERE ITEM.ITEM_ID IN(?, ?)
WHERE ITEM.ITEM_ID IN(?, ?, ?, ?)

 

 

array_contains를 사용하면 위에서 말한 문제를 깔끔하게 해결할 수 있다. 이 문법은 결과적으론 where in과 동일하다. array_contains는 왼쪽에 배열을 넣는데, 배열에 들어있는 숫자가 오른쪽(ITEM_ID)에 있다면 참이 된다.

• 이 문법은 ?에 바인딩되는 것이 딱 1개다. 배열 1개가 들어가는 것이다. 따라서 배열에 들어가는 데이터가 늘어도 SQL 구문 자체가 변하진 않는다.
• 이런 방법을 사용하면 위에서 말한 동적으로 늘어나는 SQL 구문을 걱정하지 않아도 된다. 결과적으로 데이터가 동적으로 늘어나도 같은 SQL 구문을 그대로 사용해서 성능을 최적화할 수 있다.

# 아래 두 SQL은 같다
SELECT ... WHERE ARRAY_CONTAINS([1,2,3], ITEM.ITEM_ID)
SELECT ... ITEM.ITEM_ID WHERE IN(1,2,3)

 

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

 

---

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

이전 섹션에서 SimpleQuery 패키지를 만들어 JPA에서 DTO를 직접 조회하는 코드를 작성했었다. 이번에도 비슷하게 진행하는데, 컬렉션을 조회해야 한다는 점에서 조금은 다르다.

• 화면이나 API에 의존하는 로직과 핵심 비즈니스 로직은 라이프 사이클이 약간 다르기 때문에 아래처럼 아예 class를 분리해서 만드는 게 좋다.
  • OrderRepository = 엔티티 조회용으로, 핵심 비즈니스 로직에 사용됨
  • OrderQueryRepository = 화면이나 API에 의존관계가 있는 조회 로직을 떼어내서 모아 둔 것

 

 

아래 findOrderQueryDtos() 메서드에서 new 명령어를 사용해 DTO를 만들 때, 컬렉션을 넣으면 데이터가 증가하기 때문에 바로 넣지 않고 별도로 조회해야 한다.

• row 수가 증가하지 않는 xToOne(N:1, 1:1) 관계는 조인으로 최적화하기 쉬우므로 한 번에 조회하고, xToMany(1:N) 관계는 최적화하기 어려우므로 findOrderItems() 같은 별도의 메서드로 각각 처리한다.

@Repository
@RequiredArgsConstructor
public class OrderQueryRepository {

    private final EntityManager em;

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

 

 

JPA에서 아래 DTO들을 직접 조회한다. 기본 필드에 OrderItem을 담을 컬렉션이 들어간다. 이때, 엔티티 말고 새로 만든 DTO에 의존하도록 만들어야 한다.

• 만약 OrderApiController 안에 있는 OrderDto를 참조하게 만들면, 리포지토리가 Controller를 참조하는 의존관계가 순환된다는 문제가 생긴다. 따라서 OrderQueryRepository가 있는 패키지에 따로 OrderQueryDto를 만들어야 한다.

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

///

@Data
public class OrderItemQueryDto {

    @JsonIgnore // orderId가 중복될 필요는 없으므로 설정
    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;
    }
}

 

 

아래에서 findOrderQueryDtos() 메서드를 실행하면, Order와 xToOne 관계를 갖는 엔티티를 페치 조인하는 루트 쿼리가 1번 나간다. 이후 루프를 돌면서 컬렉션(OrderItem) N개를 추가한다. 따라서 최종 쿼리는 1 + N번이 된다.

• xToOne 관계는 조인해도 데이터 row 수가 증가하지 않는다.
• xToMany 관계는 조인하면 데이터 row 수가 증가한다.

@RestController
@RequiredArgsConstructor
public class OrderApiController {
    
    private final OrderQueryRepository orderQueryRepository;
    
    ...
    
    @GetMapping("/api/v4/orders")
    public List<OrderQueryDto> ordersV4() {
        return orderQueryRepository.findOrderQueryDtos();
    }
}

 

---

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

위에서 여전히 N + 1 문제가 해결되지 않은 걸 확인할 수 있다. 쿼리 수를 더 최적화해 보자.

 

우선 V4와 루트 조회(xToOne 관계를 페치 조인; 쿼리 1번)까진 동일하게 작성한다. 앞에선 루프를 돌면서 컬렉션을 조회하기 때문에 N번의 쿼리가 발생했다. 이 부분을 최적화해 한 번에 가져올 수 있도록 하면 된다.

• xToOne 관계를 조회하고 나서 얻은 식별자 orderId로 xToMany 관계인 OrderItem을 한꺼번에 조회하도록 하면 된다.
  1.  Order와 xToOne 관계인 엔티티를 페치 조인해 찾는다. → 루트 조회 쿼리 1번
  2. 찾은 주문 리스트에서 별도의 메서드를 통해 식별자 orderId를 뽑아내 리스트(orderIds)로 저장한다.
  3. orderIds를 array_contains에 넣어 orderId에 맞는 OrderItemQueryDto 리스트(orderItems)를 만든다. → 쿼리 1번
  4. groupingBy() 메서드를 사용해 orderId와 orderItem을 매핑해 Map에 저장한다.
  5. 이후 루프를 돌면서 Map에서 orderId에 맞는 orderItems를 꺼내 설정한다.

@Repository
@RequiredArgsConstructor
public class OrderQueryRepository {

    ...
    
    /**
     * 최적화
     * Query: 루트 1번, 컬렉션 1번
     * 데이터를 한꺼번에 처리할 때 많이 사용하는 방식
     *
     */
    public List<OrderQueryDto> findAllByDto_optimization() {
        // 루트 조회 (xToOne 코드를 모두 한 번에 조회)
        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;
    }

    public 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 = : orderIds", OrderItemQueryDto.class)
                .setParameter("orderIds", orderIds)
                .getResultList();

        return orderItems.stream()
                .collect(Collectors.groupingBy(OrderItemQueryDto::getOrderId));
    }
}

 

 

아래에서 findAllByDto_optimization() 메서드를 실행하면, Order와 xToOne 관계를 갖는 엔티티를 페치 조인하는 루트 쿼리가 1번 나간다. 이후 V4와는 다르게 루프를 돌면서 orderItem 컬렉션을 가져오는 대신, Map을 사용해 한꺼번에 가져온다. 쿼리 한 번으로 Map에 orderId와 orderItem 컬렉션을 저장하고, orderId에 맞는 orderItem 컬렉션을 Map에서 조회해 설정하기만 하면 된다. 따라서 최종 쿼리는 1 + 1번이 된다.

• Map을 사용하면 매칭 성능이 O(1)로 향상된다.

@RestController
@RequiredArgsConstructor
public class OrderApiController {

    ...
    
    @GetMapping("/api/v5/orders")
    public List<OrderQueryDto> ordersV5() {
        return orderQueryRepository.findAllByDto_optimization();
    }
}

 

---

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

JPA에서 DTO로 직접 조회할 때, 데이터를 플랫하게 가져오도록 최적화하면 쿼리 1번만으로 모든 데이터를 가져올 수 있다. DB에서 한 번에 모든 데이터를 가져오기 위해 모든 엔티티를 조인하고, SQL 한 줄에 가져올 수 있도록 만들어야 한다. 조인한 다음 OrderFlatDto로 만들어 리스트로 반환한다.

@Repository
@RequiredArgsConstructor
public class 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();
    }
}

 

 

조인된 엔티티들에서 필요한 필드를 모두 받아올 수 있도록 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;
    }
}

 

 

아래 코드에서 findAllByDto_flat() 메서드를 실행해 데이터를 플랫하게 쿼리 1번으로 가져온다. 물론 아래와 같은 단점도 존재한다.

• 조인으로 인해 DB에서 애플리케이션에 전달하는 데이터에 중복 데이터가 추가되기 때문에 상황에 따라 V5 코드보다 느릴 수도 있다.
• 애플리케이션에서 추가 작업을 많이 해야 한다.
• 페이징이 불가능하다.

@RestController
@RequiredArgsConstructor
public class 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());
    }
}

 

참고
이때 OrderFlatDto로 가져온 값을 OrderQueryDto 스펙에 맞추고, 중복 데이터를 제거한 뒤 반환하기 위해 stream().collect().entrySet().stream().map().collect() 같은 복잡한 메서드를 사용했다.

groupingBy() 메서드로 객체를 묶을 때, 어떤 값으로 묶을 건지 정해야 한다. @EqualsAndHashCode 애노테이션을 사용해 서로 다른 두 객체를 묶을 때 기준으로 잡을 값을 설정할 수 있다. 아래에선 orderId를 기준으로 OrderQueryDto와 OrderItemQueryDto를 묶겠다고 설정했다고 보면 된다.

@Data
@EqualsAndHashCode(of = "orderId")
public class 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;
    }
}

 

---

정리

[엔티티 조회]
- V1: 엔티티를 조회해서 그대로 반환
- V2: 엔티티 조회 후 API 스펙에 맞는 DTO로 변환
- V3: 페치 조인으로 쿼리 수 최적화 → 컬렉션에서 N + 1 문제 발생
- V3.1: 컬렉션 페이징과 한계 돌파
    - 컬렉션은 페치 조인 시 페이징이 불가능함
    - xToOne 관계는 페치 조인으로 쿼리 수 최적화
    - 컬렉션은 페치 조인 대신 지연 로딩을 유지하고, hibernate.default_batch_fetch_size나 @BatchSize로 최적화

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

 

권장 순서는 아래와 같다.

1. 엔티티 조회 방식으로 우선 접근
   1. 페치 조인으로 쿼리 수를 최적화
   2. 컬렉션 최적화
      1. 페이징이 필요 O → hibernate.default_batch_fetch_size나 @BatchSize로 최적화
      2. 페이징이 필요 X → 페치 조인 사용
2. DTO 조회 방식 사용
3. NativeSQL이나 스프링 JdbcTemplate 사용

 

참고
엔티티 조회 방식은 페치 조인이나 hibernate properties 옵션이나 @BatchSize 애노테이션을 사용해 코드를 거의 수정하지 않고 다양하게 성능 최적화를 시도할 수 있다.
반면, DTO를 직접 조회하는 방식은 성능을 최적화하거나 성능 최적화 방식을 변경할 때 많은 코드를 변경해야 한다.

 

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

 

DTO로 조회하는 방법도 각각 장단점이 있다. 예를 들어 V4, V5, V6에서 단순하게 쿼리가 1번 실행된다고 해서 V6이 항상 좋은 방법인 것은 아니다.

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

 

참고
대부분의 경우엔 페치 조인까지만 적용해도 웬만한 문제는 다 해결된다. 사용자가 너무 많은 애플리케이션이라면 DTO 조회 방식까지 갈 수도 있지만 보통은 Redis 같은 캐시를 사용해 해결한다.

추가로, 엔티티는 직접 캐싱하면 안 된다. 엔티티는 보통 영속성 컨텍스트에 올라가 관리되기 때문에 캐시에 잘못 올라가면 복잡한 문제가 생길 수도 있다. 따라서 캐시할 땐 엔티티를 DTO로 변환해서 캐싱하자.