[Spring Boot + JPA] API 개발과 성능 최적화 - 3. 컬렉션 조회 최적화

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

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

 

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

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

 

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

@RestController
@RequiredArgsConstructor
public class OrderApiController {

    private final OrderRepository orderRepository;

    @GetMapping("/api/v1/orders")
    public List<Order> orderV1() {
        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;
    }
}

 

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

orderV2 추가

@RestController
@RequiredArgsConstructor
public class OrderApiController {

    private final OrderRepository orderRepository;

    @GetMapping("/api/v2/orders")
    public List<OrderDTO> orderV2() {
        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 String orderDate;
        private OrderStatus orderStatus;
        private Address address;
        private List<OrderItem> orderItems;

        public OrderDTO(Order order) {
            orderId = order.getId();
            name = order.getMember().getName();
            orderDate = order.getOrderDate();
            orderStatus = order.getStatus();
            address = order.getDelivery().getAddress();
            order.getOrderItems().stream().forEach(o -> o.getItem().getName()); // 지연로딩 강제 초기화
            orderItems = order.getOrderItems();
        }
    }
}

OrderDTO 생성자를 보면 OrderItems 역시 지연로딩으로 호출하고 있고 프록시 객체가 아닌 실제 객체를 가지고 오도록 강제 초기화를 해주었다.

하지만, OrderItem 역시 엔티티이기 때문에 필요한 필드를 포함하는 OrderItemDTO를 만들어서 생성해줘야 한다.

Address와 같은 ValueObject는 그대로 조회해도 괜찮다.(엔티티가 아니기 때문에)

 

OrderItemDTO 생성

@Data
static class OrderDTO {
    private Long orderId;
    private String name;
    private String 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(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();
    }
}

• 지연 로딩으로 N+1 문제가 발생하여 너무 많은 SQL 실행
• SQL 실행 수
  • order : 1번
  • member, address : N번(order 조회 수만큼)
  • orderItem : N번(order 조회 수만큼)
  • item : N번(orderItem 조회 수만큼)

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

 

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

orderV3 추가

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

 

OrderRepository.findAllWithItem 추가

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

• 페치 조인으로 SQL이 1번만 실행됨
• distinct를 사용한 이유는 1대다 조인이 있으므로 데이터베이스 row가 증가한다. 그 결과 같은 order 엔티티의 조회 수도 증가하게 된다.
  JPA의 distinct는 SQL에 distinct를 추가하고, 더해서 같은 엔티티가 조회되면, 애플리케이션에서 중복을 걸러준다.
  이 예에서 order가 컬렉션 페치 조인 때문에 중복 조회 되는 것을 막아준다.

컬렉션 조회에서 일대다 관계 페치 조인의 단점 

페이징 처리가 불가능하다는 컬렉션 페치조인의 치명적인 단점이 있다.

 

OrderRepository.findAllWithItem 페이징 처리 추가

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

실행로그

로그를 잘 살펴보면 페이징 쿼리가 없다.(예 : LIMIT절)

또, WARN 경고 로그에 메모리에서 페이징 처리를 한다는 내용이 있다. 만약 데이터가 10000건이라면 10000개를 메모리에 올리고 페이징 처리를 하게 되어 치명적인 에러를 발생할 것이다.

따라서 일대다 페치조인에서 페이징을 하면 안 된다.

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

 

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

페이징과 한계 돌파

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

한계 돌파

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

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

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

orderV3_page 추가

@GetMapping("/api/v3.1/orders")
public List<OrderDTO> orderV3_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;
}

 

application.yml 글로벌 설정 추가

spring:
  jpa:
    properties:
      hibernate:
        default_batch_fetch_size: 100

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

장점

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

결론

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

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

 

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

orderV4 추가

@GetMapping("/api/v4/sample-orders")
public List<OrderQueryDTO> orderV4() {
    return orderQueryRepository.findOrderDTOs();
}

 

OrderQueryDTO 생성

@Data
public class OrderQueryDTO {

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

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

 

OrderItemQueryDTO 생성

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

 

OrderQueryRepository 생성

@Repository
@RequiredArgsConstructor
public class OrderQueryRepository {
    private final EntityManager em;
    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;
    }

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

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

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

 

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

orderV5 추가

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

 

OrderQueryRepository

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 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 List<Long> toOrderIds(List<OrderQueryDTO> result) {
    List<Long> orderIds = result.stream()
            .map(o -> o.getOrderId())
            .collect(Collectors.toList());
    
    return orderIds;
}

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

 

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

ordersV6 추가

@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에 생성자 추가

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

    // ...

    public OrderQueryDTO(Long orderId, String name, String 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;
    }
}

 

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 String orderDate;
    private OrderStatus orderStatus;
    private Address address;

    private String itemName;
    private int orderPrice;
    private int count;

    public OrderFlatDTO(Long orderId, String name, String 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;
    }
}

• 해당 코드들을 수행했을 때 실행되는 Query는 1번이다.
• 단점
  • 쿼리는 한 번이지만 조인으로 인해 DB에서 애플리케이션에 전달하는 데이터에 중복 데이터가 추가되므로 상황에 따라 V5보다 느릴 수도 있다.
  • 메모리에 데이터를 올려두고 객체를 매핑하기 때문에 애플리케이션에서 추가 작업이 크다.
  • 페이징이 불가능하다.

 

📌 API 개발 고급 정리

엔티티조회

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

 

DTO 직접 조회

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

 

권장 순서

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

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

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

 

 

DTO 조회 방식의 선택지

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

 

 

---

해당 글은 인프런의 [실전! 스프링 부트와 JPA 활용 2 - API 개발과 성능 최적화] 강의를 정리한 내용입니다.

실전! 스프링 부트와 JPA 활용2 - API 개발과 성능 최적화 - 인프런 | 강의