[JPA 활용 2] 4. API 개발 고급 - 컬렉션 조회 최적화

2022. 4. 22. 13:58

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

OrderApiController 생성

package jpabook.jpashop.api;

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

@RestController
@RequiredArgsConstructor
public class OrderApiController {
    private final OrderService orderService;

    @GetMapping("/api/v1/orders")
    public List<Order> ordersV1() {
        List<Order> orders = orderService.findOrders(new OrderSearch());
        for (Order order : orders) {
            order.getMember().getName();            // 강제 초기화   
            order.getDelivery().getAddress();          // 강제 초기화
            List<OrderItem> orderItems = order.getOrderItems();
            for (OrderItem orderItem : orderItems) {
                orderItem.getItem().getName();          // 강제 초기화
            }
        }
        return orders;
    }

}

테스트

모든 데이터를 가져온 것을 볼 수 있습니다.

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

OrderApiController 코드 추가

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.OrderSearch;
import jpabook.jpashop.service.OrderService;
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.*;
import java.util.stream.Collectors;

@RestController
@RequiredArgsConstructor
public class OrderApiController {
    
    ...

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

        return result;
    }

    @Data
    static class OrderDto{
        private Long orderId;
        private String name;
        private LocalDateTime 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.getMember().getAddress();
            order.getOrderItems().stream().forEach(o -> o.getItem().getName());
            orderItems = order.getOrderItems();
        }
    }
}

테스트

엔티티를 사용하지않고 DTO를 만들어 반환해주었습니다. 하지만, DTO안 필드를 보시면 엔티티로 만들어진 컬렉션이 있습니다.

private List<OrderItem> orderItems;

이렇게 되면 OrderItem의 스펙이 외부로 모두 노출되고 있습니다. 모든 엔티티의 의존을 끊어야합니다. OrderDto 내의 OrderItem도 DTO로 변환해줍시다.

OrderApiController 코드 변경

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.OrderSearch;
import jpabook.jpashop.service.OrderService;
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.*;
import java.util.stream.Collectors;

@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<OrderItemDto> orderItems;

        public OrderDto(Order order) {
            orderId = order.getId();
            name = order.getMember().getName();
            orderDate = order.getOrderDate();
            orderStatus = order.getStatus();
            address = order.getMember().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.getOrderPirce();
            count = orderItem.getItem().getPrice();
        }
    }
}

테스트

위처럼 DTO로 감싸서 필요한 데이터만 JSON에 나올수 있도록 했습니다.

코드 최적화

    //전
    @GetMapping("/api/v2/orders")
    public List<OrderDto> ordersV2() {
        List<Order> orders = orderService.findOrders(new OrderSearch());
        List<OrderDto> result = orders.stream()
                .map(o -> new OrderDto(o))
                .collect(Collectors.toList());

        return result;
    }

    //후
    @GetMapping("/api/v2/orders")
    public List<OrderDto> ordersV2() {
        return orderService.findOrders(new OrderSearch()).stream()
                .map(OrderDto::new)
                .collect(toList());
    }

람다와 import를 이용해서 조금 더 코드를 깔끔하게 변경할 수 있습니다.

테스트를 해보면 쿼리문이 생각만큼 혹은 생각보다 많이 나가는 걸 확인할 수 있을 겁니다. 더 최적화를 하기위해 이전에 써보았던 fetch join을 적용해봅시다

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

OrderApiController 코드 추가

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.OrderSearch;
import jpabook.jpashop.service.OrderService;
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.*;
import java.util.stream.Collectors;

import static java.util.stream.Collectors.*;

@RestController
@RequiredArgsConstructor
public class OrderApiController {
    ...

    @GetMapping("/api/v3/orders")
    public List<OrderDto> ordersV3() {
        return orderService.findAllWithMemberDeliveryItem().stream()
                .map(OrderDto::new)
                .collect(toList());
    }

    ...
}

OrderRepository 코드 추가

package jpabook.jpashop.repository;

import jpabook.jpashop.domain.Member;
import jpabook.jpashop.domain.Order;
import jpabook.jpashop.repository.order.simplequery.OrderSimpleQueryDto;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Repository;
import org.springframework.util.StringUtils;

import java.util.*;

import javax.persistence.EntityManager;
import javax.persistence.TypedQuery;
import javax.persistence.criteria.*;

@Repository
@RequiredArgsConstructor
public class OrderRepository {

	...

    public List<Order> findAllWithMemberDeliveryItem(){
        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();
    }
}

OrderService 추가 코드는 Repository 메소드만 return하기때문에 추가하지 않았습니다.

테스트

조인을 잘 아시는분들은 2개의 order와 4개의 아이템을 join하면 4개의 컬럼이 나온다는 것을 알 수 있을 겁니다. 여기서 문제는 데이터가 뻥튀기가 된다는 것 입니다. (뻥튀기란 중복된 데이터인 필요하지 않은 데이터가 여러개가 생긴다는 것 입니다.) 지금은 1개씩 뻥튀기 됐지만, 이런 엔티티가 많이 연관되어 있을 경우 몇개가 뻥튀기가 될지 알 수 없을 것 입니다.

Order의 참조값을 확인해보면 같은 참조값이 2번씩 나오는 걸 확인할 수 있습니다. 해당 문제는 distinct를 썼던 걸 기억했다면 해결할 수 있습니다. 실제로 dinstinct를 써보면 중복된 데이터가 사라지는 걸 확인할 수 있습니다. 여기서 데이터가 사라지는 이유는 JPA에서 distinct가 있고, 갖고온 데이터가 같은 id 값이면 제거해주는 기능을 했기때문에 postman에서는 중복된 데이터가 사라지는 것 입니다.

DB는 확인해보면 여전히 컬럼이 4개 있습니다. (참고로, DB에서 distinct는 모든 데이터가 같아야 합니다.)

해당 방법은 어마어마한 단점이 있습니다. 바로, 페이징이 불가능하다는 점 입니다. (DB는 중복된 데이터가 그대로있지만, 애플리케이션에서 중복을 제거해주었기때문에 제대로된 페이징을 할 수 없기 때문입니다.) (이전 distinct 설명에서도 말했듯 중요하기때문에 이해합시다!)

참고
컬렉션 페치 조인을 사용하면 페이징이 불가능하다. 하이버네이트는 경고 로그를 남기면서 모든 데이터를 DB에서 읽어오고, 메모리에서 페이징 해버린다. (매우 위험하다) 자세한 내용은 자바 ORM 표준 JPA 프로그래밍의 페치 조인 부분을 참고.

참고
컬렉션 페치 조인은 1개만 사용할 수 있다. 컬렉션 둘 이상에 페치 조인을 사용하면 안된다. 데이터가 부정합하게 조회될 수 있다. 자세한 내용은 자바 ORM 표준 JPA 프로그래밍 참고.

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

페이징과 한계 돌파

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

한계 돌파

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

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

application.yml에 hibernate 하위에 아래 설정을 추가해줍니다.

default_batch_fetch_size: 100

후 findAllWithMemberDelivery를 조회한 후 orderItem을 지연로딩으로 해주면 100개의 데이터를 한번에 갖고 옵니다.

장점
- 쿼리 호출 수가 1+N -> 1+1로 최적화 됩니다. (데이터가 많은 경우에는 더 많이 나가긴합니다.)
- 조인보다 DB 데이터 전송량이 최적화된다. (Order와 OrderItem을 조인하면 Order가 OrderItem 만큼 중복해서 조회된다. 해당 방법은 각각 조회하므로 전송해야할 중복 데이터가 없다.)
- 페치 조인 방식과 비교해서 쿼리 호출 수가 약간 증가하지만, DB 데이터 전송량이 감소한다.
- 컬렉션 페치 조인은 페이징이 불가능 하지만 해당 방법은 페이징이 가능하다.
결론
- ToOne 관계는 페치 조인해도 페이징에 영향을 주지 않는다. 따라서, ToOne관계는 페치조인으로 쿼리 수를 줄이고 해결하고, 나머지는 batch_fetch_size로 최적화하자.

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

ToOne 먼저 받고 페이징 후 지연로딩 전략 코드

OrderApiController 코드 추가

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.OrderSearch;
import jpabook.jpashop.service.OrderService;
import lombok.Data;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

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

import static java.util.stream.Collectors.*;

@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) {
        return orderService.findAllWithMemberDelivery(offset, limit).stream()
                .map(OrderDto::new)
                .collect(toList());
    }

	...
}

OrderRepository 코드 추가

package jpabook.jpashop.repository;

import jpabook.jpashop.domain.Member;
import jpabook.jpashop.domain.Order;
import jpabook.jpashop.repository.order.simplequery.OrderSimpleQueryDto;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Repository;
import org.springframework.util.StringUtils;

import java.util.*;

import javax.persistence.EntityManager;
import javax.persistence.TypedQuery;
import javax.persistence.criteria.*;

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

    ..
}

위와 같이 ToOne에서 페이징을 한 뒤, ToMany의 경우 지연 로딩으로 batch_size를 정해 가져오는 방법을 사용하면 된다.

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

OrderApiController 코드 추가

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.OrderSearch;
import jpabook.jpashop.repository.order.query.OrderQueryDto;
import jpabook.jpashop.service.OrderService;
import jpabook.jpashop.service.order.query.OrderQueryService;
import lombok.Data;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

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

import static java.util.stream.Collectors.*;

@RestController
@RequiredArgsConstructor
public class OrderApiController {
	...
    private final OrderQueryService orderQueryService;

    ...

    @GetMapping("/api/v4/orders")
    public List<OrderQueryDto> ordersV4() {
        return orderQueryService.findOrderQueryDtos();
    }

    ...
}

repository.order.query 패키지 생성 후 OrderQueryDto 생성

package jpabook.jpashop.repository.order.query;

import jpabook.jpashop.domain.Address;
import jpabook.jpashop.domain.OrderStatus;
import lombok.Data;
import java.util.*;

import java.time.LocalDateTime;

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

OrderItemQueryDto 생성

package jpabook.jpashop.repository.order.query;

import lombok.Data;

@Data
public class OrderItemQueryDto {

    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 생성

package jpabook.jpashop.repository.order.query;

import jpabook.jpashop.domain.OrderItem;
import lombok.RequiredArgsConstructor;
import java.util.*;
import org.springframework.stereotype.Repository;

import javax.persistence.EntityManager;

@Repository
@RequiredArgsConstructor
public class OrderQueryRepository {

    private final EntityManager em;

    /**
     * join해서 갖고온 데이터에 ToMany 데이터를 Dto 로 갖고온다.
     */
    public List<OrderQueryDto> findOrderQueryDtos() {
        List<OrderQueryDto> result = findOrderQueryDto();

        result.forEach(o -> {
            List<OrderItemQueryDto> orderItems = findOrderItems(o.getOrderId());
            o.setOrderitems(orderItems);
        });

        return result;
    }

    /**
     * OrderItemQueryDto.orderItems 필드 값 채우는 메소드
     */
    private List<OrderItemQueryDto> findOrderItems(Long orderId) {
        return em.createQuery(
                "select new jpabook.jpashop.repository.order.query.OrderItemQueryDto(oi.order.id, oi.item.name, oi.orderPirce, oi.count)" +
                        " from OrderItem oi" +
                        " join oi.item i" +
                        " where oi.order.id = :orderId", OrderItemQueryDto.class)
                .setParameter("orderId", orderId)
                .getResultList();
    }

    /**
     * dto로 직접 조회 (ToMany는 따로 담아줘야하기 때문에 ToMany빼고 join해서 한번에 데이터를 갖고온다.)
     */
    public List<OrderQueryDto> findOrderQueryDto() {
        return em.createQuery(
                "select new jpabook.jpashop.repository.order.query.OrderQueryDto(o.id, o.member.name, o.orderDate, o.status, o.delivery.address)" +
                        " from Order o" +
                " join o.member m" +
                " join o.delivery d", OrderQueryDto.class)
                .getResultList();
    }
}

service.order.query 패키지 생성 후 OrderQueryService 생성

package jpabook.jpashop.service.order.query;

import jpabook.jpashop.repository.order.query.OrderQueryDto;
import jpabook.jpashop.repository.order.query.OrderQueryRepository;
import jpabook.jpashop.repository.order.simplequery.OrderSimpleQueryDto;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;

@Service
@RequiredArgsConstructor
@Transactional(readOnly = true)
public class OrderQueryService {
    private final OrderQueryRepository orderQueryRepository;

    public List<OrderQueryDto> findOrderQueryDtos() {
        return orderQueryRepository.findOrderQueryDtos();
    }
}

Controller -> Repository 바로 접근해도 상관없지만, 후에 리팩토링할 때 Service를 하나 두는게 더 좋아보여서 Service를 만들어 주었다.

Query 루트 1번, 컬렉션 N번 실행
ToOne(N:1, 1:1) 관계들은 join을 통해 한번의 쿼리로 조회하고, ToMany(1:N) 관계는 각각 별도로 처리했습니다.
- 이런 방식을 선택한 이유
  1. ToOne 관계는 조인해도 데이터 row 수가 증가하지 않는다.
  2. ToMany 관계는 조인하면 row 수가 증가한다.
즉, row 수가 증가하지 않는 ToOne 관계는 조인으로 최적화 하기 쉬우므로 한 번에 조회하고, ToMany 관계는 최적화 하기 어려우므로 별도의 메소드를 통해 조회했다.

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

V4을 실행해서 확인해보면 order 수에 따라서 추가 쿼리가 N개만큼 나가는 것을 확인할 수 있습니다. 이 또한 최적화 시킬 수 있다고합니다. (일명 컬렉션 조회 최적화!)

OrderQueryRepository 코드 추가

package jpabook.jpashop.repository.order.query;

import jpabook.jpashop.domain.OrderItem;
import lombok.RequiredArgsConstructor;
import java.util.*;
import java.util.stream.Collectors;

import org.springframework.stereotype.Repository;

import javax.persistence.EntityManager;

@Repository
@RequiredArgsConstructor
public class OrderQueryRepository {

    ...

    /**
     * Order 수에 따른 N번에 추가 쿼리를 1번의 쿼리문으로
     */
    public List<OrderQueryDto> findAllByDto_optimization() {
        List<OrderQueryDto> result = findOrderQueryDto();

        List<Long> ordersIds = result.stream()
                .map(o -> o.getOrderId())
                .collect(Collectors.toList());

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

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

        result.forEach(o -> o.setOrderitems(orderItempMap.get(o.getOrderId())));

        return result;
    }
}

해당 result를 받는 Service와 Controller에 코드 추가만 해주면 작동합니다. 실제로 N번의 쿼리문이 1번의 쿼리문으로 바뀐걸 확인할 수 있습니다.

위의 하나의 메소드를 아래와 같이 commant+option+m을 이용해 리팩토링 해주었습니다.

    /**
     * Order 수에 따른 N번에 추가 쿼리를 1번의 쿼리문으로
     */
    public List<OrderQueryDto> findAllByDto_optimization() {
        List<OrderQueryDto> result = findOrderQueryDto();

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

        result.forEach(o -> o.setOrderitems(orderItempMap.get(o.getOrderId())));

        return result;
    }

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

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

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

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

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

OrderQueryRepository 코드 추가

package jpabook.jpashop.repository.order.query;

import jpabook.jpashop.domain.OrderItem;
import lombok.RequiredArgsConstructor;
import java.util.*;
import java.util.stream.Collectors;

import org.springframework.stereotype.Repository;

import javax.persistence.EntityManager;

@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.orderPirce, oi.count)" +
                        " from Order o" +
                        " join o.member m" +
                        " join o.delivery d" +
                        " join o.orderItems oi" +
                        " join oi.item i", OrderFlatDto.class)
                .getResultList();
    }
}

해당 result를 받는 Service와 Controller에 코드 추가만 해주면 작동합니다. 실제로 1번의 쿼리문으로 모든 데이터를 갖고오는 것을 볼 수 있습니다. 페이징도 가능합니다. 하지만, OrderId를 기준으로 페이징을 하고싶은 경우에는 페이징이 불가능합니다.

orderid 기준으로 페이징이 불가능한 이유는 아래 get 요청에 나온 응답을 보시면 쉽게 알 수 있습니다. orderId 기준으로 index가 증가하는 것이아닌 orderItem 기준으로 Index가 증가하기 때문입니다.

위를 보시면 orderId, member name, address 등 중복된 결과가 많습니다. 이렇게 중복된 결과를 지워낼 수 있는 코드는 아래와 같습니다.

중복된 데이터 제거 방법

OrderApiController 코드 추가

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.OrderSearch;
import jpabook.jpashop.repository.order.query.OrderFlatDto;
import jpabook.jpashop.repository.order.query.OrderItemQueryDto;
import jpabook.jpashop.repository.order.query.OrderQueryDto;
import jpabook.jpashop.service.OrderService;
import jpabook.jpashop.service.order.query.OrderQueryService;
import lombok.Data;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

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

import static java.util.stream.Collectors.*;

@RestController
@RequiredArgsConstructor
public class OrderApiController {
	
    ...

    @GetMapping("/api/v7/orders")
    public List<OrderQueryDto> ordersV7() {
        List<OrderFlatDto> flats = orderQueryService.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 추가

package jpabook.jpashop.repository.order.query;

import jpabook.jpashop.domain.Address;
import jpabook.jpashop.domain.OrderStatus;
import lombok.Data;
import lombok.EqualsAndHashCode;

import java.util.*;

import java.time.LocalDateTime;

@Data
@EqualsAndHashCode(of = "orderId")	// orderId 를 기준으로 groupingBy
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;
    }

}

Query 1번
단점
- 쿼리는 1번이지만 조인으로 인해 DB에서 애플리케이션에 전달하는 데이터에 중복 데이터가 추가되므로 상황에 따라 V5 보다 더 느릴 수 있다.
- 애플리케이션에 추가 작업이 크다.
- 페이징 불가능 (orderItem 기준으로는 페이징 가능)

컬렉션 조회 최적화 정리

엔티티 조회
- 엔티티를 조회해서 그대로 반환 : V1
- 엔티티 조회 후 DTO로 반환 : V2
- 페치 조인으로 쿼리 수 최적화 : V3
- 컬렉션 페이징과 한계 돌파 : V3.1
  - 컬렉션은 페치 조인 시 페이징이 불가능
  - ToOne 관계는 페치 조인으로 쿼리 수 최적화
  - 컬렉션은 페치 조인 대신에 지연 로딩을 유지하고, hibernate.deault_batch_fetch_size, @BatchSize로 최적화
DTO 직접 조회
- JPA에서 DTO를 직접 조회 : V4
- 컬렉션 조회 최적화 - 일대다 관계인 컬렉션은 IN 절을 활용해서 메모리에 미리 조회해서 최적화 : V5
- 플랫 데이터 최적화 - JOIN 결과를 그대로 조회 후 애플리케이션에서 원하는 모양으로 직접 변환 : V6

권장 순서

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

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

캐시를 사용하는 경우 Entity를 캐시하지않고 Entity -> Dto로 바꾸고 Dto를 캐시해야 한다.

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

DTO 조회 방식의 선택지

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

출처

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

스프링 부트와 JPA를 활용해서 API를 개발합니다. 그리고 JPA 극한의 성능 최적화 방법을 학습할 수 있습니다., - 강의 소개 | 인프런...

www.inflearn.com

'spring > 인프런 강의 정리' 카테고리의 다른 글

[Spring Data JPA] 1. 스프링 데이터 JPA 시작 (0)	2022.05.13
[JPA 활용 2] 5. API 개발 고급 - 실무 필수 최적화 (0)	2022.04.24
[JPA 활용 2] 3. API 개발 고급 - 지연 로딩과 조회 성능 최적화 (0)	2022.04.21
[JPA 활용 2] 2. API 개발 고급 - 준비 (0)	2022.04.21
[JPA 활용 2] 1. API 개발 기본 (0)	2022.04.20

선장 일지