〰️

컬렉션 조회 최적화

•

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

•

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

◦

컬렉션(@OneToMany) 조회 최적화

public class Order {

		...

    @OneToMany(mappedBy = "order", cascade = CascadeType.ALL)
    private List<OrderItem> orderItems = new ArrayList<>();
}
Java
복사

Version #1 - Entity 직접 노출

@GetMapping("/api/v1/orders")
public List<Order> ordersV1() {
    List<Order> all = orderRepository.findAllByString(new OrderSearch());
    for (Order order : all) {
        order.getMember().getName(); // Member 강제 초기화
        order.getDelivery().getAddress(); // Delivery 강제 초기화

        List<OrderItem> orderItems = order.getOrderItems();
        orderItems.stream().forEach(o -> o.getItem().getName());  // OrderItem의 Item 강제 초기화
    }
    return all;
}
Java
복사

•

orderItem , item 관계를 직접 초기화하면 Hibernate5Module 설정에 의해 엔티티를 JSON으로
생성한다.

◦

양방향 연관관계면 무한 루프에 걸리지 않게 한곳에 @JsonIgnore 를 추가해야 한다.

•

엔티티를 직접 노출하므로 좋은 방법은 아니다.

Version #2 - DTO로 변환

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

@Getter
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();
        orderStatus = order.getStatus();
        address = order.getDelivery().getAddress();
        order.getOrderItems().stream().forEach(item -> item.getItem().getName()); // proxy 초기화
        orderItems = order.getOrderItems();
    }
}
Java
복사

•

문제점 

◦

Order Entity를 dto로 반환하고 있지만, 그 안에서 OrderItem entity를 그대로 참조하고 있음

▪

외부에 Entity가 노출됨 

▪

Entity 수정 시 API 스펙 변경

@Getter
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();
        orderStatus = order.getStatus();
        address = order.getDelivery().getAddress();
        orderItems = order.getOrderItems().stream()
                .map(orderItem -> new OrderItemDto(orderItem))
                .collect(Collectors.toList());
    }
}

@Getter
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();
    }
}
Java
복사

•

연관 관계가 있는 Entity 또한 dto로 변환하여 return

Order 2회 → Member 2회 (LAZY) → Delivery 1회 → OrderItems 2개 (LAZY) 
1 + N + N + N .... 상당히 많은 쿼리가 호출됨

Version #3 - Fetch Join 최적화

•

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(toList());
      return result;
}
Java
복사

•

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();
)
Java
복사

•

페치 조인으로 SQL이 1번만 실행됨

•

distinct 를 사용한 이유는 1대다 조인이 있으므로 데이터베이스 row가 증가한다. 

◦

그 결과 같은 order 엔티티의 조회 수도 증가하게 된다. JPA의 distinct는 SQL에 distinct를 추가하고, 더해서 같은 엔티티가 조회되면, 애플리케이션에서 중복을 걸러준다. 

◦

이 예에서 order가 컬렉션 페치 조인 때문에 중복 조회 되는 것을 막아준다.

•

단점

◦

페이징 불가능

•

그 외 유의점 

JPQL - Fetch Join 항목 참고

1) 컬렉션 페치 조인을 사용하면 페이징이 불가능하다. 하이버네이트는 경고 로그를 남기면서 모든
데이터를 DB에서 읽어오고, 메모리에서 페이징 해버린다(매우 위험하다). 
2) 컬렉션 페치 조인은 1개만 사용할 수 있다. 컬렉션 둘 이상에 페치 조인을 사용하면 안된다. 데이터가 부정합하게 조회될 수 있다. 

Vesion #3.1 - Entity를 DTO로 변환 → 페이징과 한계 돌파

•

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

•

일대다에서 일(1)을 기준으로 페이징을 하는 것이 목적. 그런데 데이터는 다(N)를 기준으로 row 생성

•

Order를 기준으로 페이징하고 싶은데, OrderItem이 기준이 됨

•

이 경우 하이버네이트는 경고 LOG를 남기고 모든 DB 데이터를 읽어서 메모리에서 페이징을 시도한다. 최악의 경우 장애로 이어질 수 있다! (OutOfMemory !!! )

•

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

•

한계 돌파!

•

먼저 ToOne 관계는 모두 Fetch Join으로 해결한다.

◦

Order →  Member @ManyToOne

◦

모든 ToOne 관계는 괜찮아!!!!! 다 fetch join으로 해결하자 

•

collection은 지연 로딩으로 조회한다.

◦

지연로딩 성능 최적화를 위해 hibernate.default_batch_fetch_size, @BatchSize를 적용한다.

spring: 
	jpa:
    properties:
	    hibernate:
        default_batch_fetch_size: 1000
YAML
복사

▪

hibernate.default_batch_fetch_size: 글로벌 설정

•

적당한 사이즈를 선택. 100~1000사이를 선택하는 것을 권장

◦

DB에 따라 in절 parameter를 1000으로 제한하기도 하기 때문에 확인 필요

◦

1000개로 설정 → DB/Application 순간 부하 증가

◦

100개로 설정 → 부하는 줄어들지만, 실행 시간이 증가한다. (여러 번의 쿼리 실행)

◦

1000이나 100이나 WAS 메모리 사용량은 같다.

▪

@BatchSize: 개별 최적화

▪

이 옵션을 사용하면 컬렉션이나, 프록시 객체를 한꺼번에 설정한 size 만큼 IN 쿼리로 조회한다.

•

장점

◦

쿼리호출수가 1+N → 1+1로 최적화된다.

◦

조인보다 DB 데이터 전송량이 최적화 된다. (Order와 OrderItem을 조인하면 Order가 OrderItem 만큼 중복해서 조회된다. 이 방법은 각각 조회하므로 전송해야할 중복 데이터가 없다.) 

◦

페치 조인 방식과 비교해서 쿼리 호출 수가 약간 증가하지만, DB 데이터 전송량이 감소한다.

◦

컬렉션 페치 조인은 페이징이 불가능 하지만 이 방법은 페이징이 가능하다.

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

Version #4 - JPA에서 DTO 직접 조회 (Collection)

•

핵심 Business Logic을 처리하는 Life Cycle과 Query (API)를 처리하는 Life Cycle을 분리해주기 위해 repository 폴더를 분기한다.

•

OrderApiController

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

•

OrderQueryRepository

public List<OrderQueryDto> findOrderQueryDtos() {
    List<OrderQueryDto> result = findOrders(); //Query 1번

		// Order별로 Item set (Collection) 
    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.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();
}
Java
복사

•

Query는 루트 1번, 컬렉션 N번 실행

◦

ToOne(N:1, 1:1) 관계들을 먼저 조회하고, ToMany(1:N) 관계는 각각 별도로 처리한다.

▪

order를 먼저 조회 → order에 대한 orderItem 처리 (Collection 처리)

◦

findOrderItems() 메소드 실행 시 각 Order에 대한 OrderItem Query 호출

▪

order 2개 → orderItem (N+1 문제 발생)

select
        orderitem0_.order_id as col_0_0_,
        item1_.name as col_1_0_,
        orderitem0_.order_price as col_2_0_,
        orderitem0_.count as col_3_0_ 
    from
        order_item orderitem0_ 
    inner join
        item item1_ 
            on orderitem0_.item_id=item1_.item_id 
    where
        orderitem0_.order_id=?
SQL
복사

•

이렇게 하는 이유?

◦

ToOne 관계는 조인해도 데이터 row 수가 증가하지 않는다.

◦

ToMany(1:N) 관계는 조인하면 row 수가 증가한다. → join으로 가져오기 힘들다. 

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

Version #5 - JPA에서 DTO 직접 조회 → 컬렉션 조회 최적화

•

OrderApiController

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

•

OrderItemRepository

public List<OrderQueryDto> findAllByDto_optimization() {

				//루트 조회(toOne 코드를 모두 한번에 조회)
        List<OrderQueryDto> result = findOrders(); // Query 1번
				
				//orderItem 컬렉션을 MAP 한방에 조회
        Map<Long, List<OrderItemQueryDto>> orderItemMap = findOrderItemMap(toOrderIds(result)); // Query 1번
        // memory에 올린 Map Data를 loop -> query 실행 X
        result.forEach(o -> o.setOrderItems(orderItemMap.get(o.getOrderId())));

        return result;
    }

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

    private Map<Long, List<OrderItemQueryDto>> findOrderItemMap(List<Long> orderIds) {
        List<OrderItemQueryDto> orderItems = em.createQuery(
                        "select new jpabook.jpashop.repository.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::getOrderId));
        return orderItemMap;
    }
Java
복사

•

Query는 루트 1번, 컬렉션 1번 실행

◦

ToOne 관계들을 먼저 조회하고, 여기서 얻은 식별자 orderId로 ToMany 관계인 OrderItem 을
한꺼번에 조회

◦

MAP을 사용해서 매칭 성능 향상(O(1))

Version #6 - JPA에서 DTO 직접 조회 → 플랫 데이터 최적화

•

OrderApiController

@GetMapping("/api/v6/orders")
    public List<OrderQueryDto> ordersV6() {
        List<OrderFlatDto> flats = orderQueryRepository.findAllByDto_flat();
        
			// 직접 중복을 걸러서 OrderQueryDto의 형태로 만든다. (API스펙 변화 없도록..) 
        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());
    }
Java
복사

•

OrderFlatDto

@Data
public class OrderFlatDto {

    private Long orderId;
    private String name;
    private LocalDateTime orderDate;
    private OrderStatus orderStatus;
    private Address address;

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

    public OrderFlatDto(Long orderId, String name, LocalDateTime orderDate, 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;
    }
}
Java
복사

•

OrderQueryDto

◦

컬렉션이 추가된 생성자 추가

◦

Stream GroupBy를 위한 EqualsAndHashCode 어노테이션 추가(Lombok) 

@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, List<OrderItemQueryDto> orderItems) {
        this.orderId = orderId;
        this.name = name;
        this.orderDate = orderDate;
        this.orderStatus = orderStatus;
        this.address = address;
        this.orderItems = orderItems;
    }
}
Java
복사

•

OrderQueryRepository

// DB에서 쿼리를 한 번에 가져오자
public List<OrderFlatDto> findAllByDto_flat() {
    return em.createQuery(
            "select new jpabook.jpashop.repository.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();
}
Java
복사

•

장점

◦

Query가 1번만 호출

◦

but Data 중복 현상 발생

•

단점

◦

Order 기준 Paging 불가

◦

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

◦

애플리케이션에서 추가 작업이 크다.

API 개발 고급 정리

엔티티 조회

•

엔티티를 조회해서 그대로 반환: V1

•

엔티티 조회 후 DTO로 변환: V2

•

페치 조인으로 쿼리 수 최적화: V3

•

컬렉션 페이징과 한계 돌파: V3.1

•

컬렉션은 페치 조인시 페이징이 불가능

◦

ToOne 관계는 페치 조인으로 쿼리 수 최적화

▪

Collection 조회가 아닐 때!

•

Member, Order 등

◦

컬렉션은 페치 조인 대신에 지연 로딩을 유지하고, hibernate.default_batch_fetch_size,
@BatchSize로 최적화

DTO 직접 조회

•

JPA에서 DTO를 직접 조회: V4

•

컬렉션 조회 최적화 - 일대다 관계인 컬렉션은 IN절을 활용해서 메모리에 미리 조회해서 최적화: V5

•

플랫 데이터 최적화 - JOIN 결과를 그대로 조회 후 애플리케이션에서 원하는 모양으로 직접 변환: V6

권장 순서

1. 엔티티 조회 방식으로 우선접근

1. 페치조인으로 쿼리 수를 최적화

2. 컬렉션 최적화

페이징 필요 hibernate.default_batch_fetch_size , @BatchSize 로 최적화

페이징 필요X → 페치 조인 사용

엔티티 조회 방식으로 해결이 안되면 DTO 조회 방식 사용

DTO 조회 방식으로 해결이 안되면 NativeSQL or 스프링 JdbcTemplate

참고
엔티티 조회 방식은 페치 조인이나, hibernate.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건인데, V4 방식을 그대로 사용하면, 쿼리가 총 1 + 1000번 실행된다. 여기서 1은 Order 를 조회한 쿼리고, 1000은 조회된 Order의 row 수다. V5 방식으로 최적화 하면 쿼리가 총 1 + 1번만 실행된다. 

→ 상황에 따라 다르겠지만 운영 환경에서 100배 이상의 성능 차이가 날 수 있다.

•

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

◦

쿼리 한번으로 최적화 되어서 상당히 좋아보이지만, Order를 기준으로 페이징이 불가능하다. 

◦

실무에서는 이정도 데이터면 수백이나, 수천건 단위로 페이징 처리가 꼭 필요하므로, 이 경우 선택하기 어려운 방법이다. 

◦

데이터가 많으면 중복 전송이 증가해서 V5와 비교해서 성능 차이도 미비하다.

엔티티 조회 vs DTO 조회
엔티티를 조회하게 되면 해당 엔티티의 모든 필드를 조회한다.
따라서 데이터 조회 성능에서 필요한 필드만 찍어서 조회하는 것과 비교해서 필드가 많다면 성능에 차이가 발생할 수 있다.
엔티티 조회를 기본으로 사용하는 것이 권장되지만, 상황에 따라 DTO로 직접 조회하는 방식이 더 단순한 경우도 많다.