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

윤경·2021년 10월 29일
JPASpringbootTIL
1

Spring Boot

목록 보기
52/79
post-thumbnail

V1. 엔티티 직접 노출

  • 엔티티가 변하면 API 스펙이 변한다.
  • 트랜잭션 안에서 지연 로딩 필요
  • 양방향 연관관계 문제

V2. 엔티티를 조회해서 DTO로 변환(fetch join 사용X)

  • 트랜잭션 안에서 지연 로딩 필요

V3. 엔티티를 조회해서 DTO로 변환(fetch join 사용O)

  • 페이징 시에는 N 부분을 포기해야함(대신에 batch fetch size? 옵션 주면 N -> 1 쿼리로 변경
    가능)

V4.JPA에서 DTO로 바로 조회, 컬렉션 N 조회 (1+NQuery)

  • 페이징 가능

V5.JPA에서 DTO로 바로 조회, 컬렉션 1 조회 최적화 버전 (1+1Query)

  • 페이징 가능

V6. JPA에서 DTO로 바로 조회, 플랫 데이터(1Query) (1 Query)

  • 페이징 불가능

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

목표

주문 내역에서 주문한 상품 정보를 추가로 조회
Order 기준으로 컬력션인 OrderItem와 Item이 필요

앞의 예제에서는 XToOne(OneToOne, ManyToOne) 관계만 있었으나 이번에는 컬렉션인 일대다 관계(OneToMany)를 조회하고 최적화하는 방법을 알아본다.

단축키

iter + tab: 으로 인텔리제이에서 for문 자동생성

컬렉션 노출시키기 (포스트맨)

  • orderItem, item 관계를 직접 초기화하면 Hibernate5Module 설정에 의해 엔티티를 JSON으로 생성한다.
  • 양방향 연관관계면 무한 루프에 걸리지 않도록 한 곳에 @JsonIgnore를 추가해야 한다.
  • 이 방법 또한 엔티티를 직접 노출시키므로 좋은 방법은 아니다.

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

📌 @Getter대신 @Data를 써도는 되지만 @Data가 제공하는게 너무 많아서 @Getter를 쓰는게 나을 수도

포스트맨원하는 결과(주문 아이템에 대해서는 이름, 가격, 수량만 알고싶은)

  • V2는 지연 로딩으로 너무 많은 SQL을 실행시킨다.
  • SQL 실행 수
    - order 1번
    - member, address N번(order 조회 수 만큼)
    - orderItem N번(order 조회 수 만큼)
    - item N번(orderItem 조회 수 만큼)

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

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

: fetch join으로 SQL이 한 번만 실행된다.

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

  • 단점
    : 페이징 불가능!!
    일대다를 패치조인 하는 순간 페이징이 불가능해진다. (페이징 쿼리가 아예 안 나감)

참고
컬렉션 페치 조인을 사용하면 페이징이 불가능하다. 하이버네이트는 경고 로그를 남기면서 모든 데이터를 DB에서 읽어오고, 메모리에서 페이징 해버린다. (매우 위험!!)

자세한 내용은 자바 ORM 표준 JPA 프로그래밍의 페치 조인 부분 참고

참고
컬렉션 페치 조인은 1개만 사용할 수 있다. 컬렉션 둘 이상에 페치 조인을 사용하면 안된다.
데이터가 부정합하게 조회될 수 있다.

자세한 내용은 자바 ORM 표준 JPA 프로그래밍을 참고

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

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

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

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

해결

페이징 + 컬렉션 엔티티를 함께 조회하려면?

코드도 단순, 성능 최적화도 보장되는 강력한 방법? (대부분의 페이징 + 컬렉션 엔티티 조회 문제는 이 방법으로 해결 가능. 사실 딱히 다른 방법도 없음.)

  • 먼저 XToOne(OneToOne, ManyToOne) 관계(Order 입장에서 member, delivery 같은 관계)를 모두 페치 조인한다.
    XToOne 관계는 row 수를 증가시키지 않으므로 페이징 쿼리에 영향을 주지 않는다.

  • 컬렉션은 지연 로딩으로 조회한다.

  • 지연 로딩 성능 최적화를 위해 hibernate.default_batch_fetch_size, @BatchSize를 적용
    - hibernate.default_batch_fetch_size: 글로벌 설정
    - @BatchSize: 개별 최적화 (컬렉션은 컬렉션 필드에, 엔티티는 엔티티 클래스에 적용)
    - 이 옵션을 사용하면 컬렉션이나, 프록시 객체를 한꺼번에 설정한 size 만큼 IN 쿼리로 조회한다.

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

포스트맨 두 번째 멤버부터 보여줌

default_batch_fetch_size: 100

➡️ hibernate.default_batch_fetch_size 덕분에 N+1 문제에서 어느정도 해방될 수 있음

장점

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

결론

xToOne 관계는 페치 조인해도 페이징에 영향을 주지 않는다. 따라서 xToOne 관계는 페치 조인으로 쿼리 수를 줄여 해결하고 나머지(컬렉션)는 hibernate.default_batch_fetch_size 로 최적화하기

참고
hibernate.default_batch_fetch_size 의 크기는 적당한 사이즈를 골라야 한다.
(최소는 없지만 최대는 1000) 100~1000 사이를 선택하는 것을 권장한다.

이 전략은 SQL IN 절을 사용하는데, 데이터베이스에 따라 IN절 파라미터를 1000으로 제한하기도 한다. 1000으로 잡으면 한 번에 1000개를 DB에서 애플리케이션에 불러오므로 DB에 순간 과부하가 올 수 있다.

하지만 애플리케이션은 100이든 1000이든 결국 전체 데이터를 로딩해야 하므로 데이터 사용량이 같다. 1000으로 설정하는 것이 성능상 가장 좋지만, 결국 DB든 애플리케이션이든 순간 부하를 어디까지 견딜 수 있는지로 결정하자.

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

단축키

fn + F2: 다음 에러로 이동하기

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

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

    /**
     * 쿼리를 한 번 날리고 메모리에 map으로 전부 가져온 다음
     * 메모리에서 매칭을 해 값을 세팅
     * 쿼리는 총 2번밖에 발생 안 함
     */
    public List<OrderQueryDto> findAllByDto_optimization() {
        // 쿼리 한 번
        List<OrderQueryDto> result = findOrders();

        List<Long> orderIds = result.stream()
                .map(o -> o.getOrderId())   // OrderQueryDto를 getOrderId로 바꿈. 그럼 이제 원하던 orderIds가 된 것
                .collect(Collectors.toList());

        // 쿼리 한 번
        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();

        // orderItems 그대로도 좋지만 그래도 한 번 최적화해주기(map으로 바꿔)
        // key가 getOrderId, value는 OrderItemQueryDto
        Map<Long, List<OrderItemQueryDto>> orderItemMap = orderItems.stream()
                .collect(Collectors.groupingBy(orderItemQueryDto -> orderItemQueryDto.getOrderId()));// getOrderId를 기준으로 map으로 바꿈

        result.forEach(o -> o.setOrderItems(orderItemMap.get(o.getOrderId())));

        return result;
    }

쿼리1쿼리2이렇게 쿼리가 총 두 번밖에 발생하지 않는다.

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

많은 코드를 직접 작성하되 페치 조인보다는 select 양이 줄어든다는 이점은 있다.

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

쿼리 딱 한 번

장점

  • Query: 1번뿐

단점

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

아이고 괄호 한 번 잘못했다가 삽질이나 하고,,🤢

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

[8] API 개발 고급 정리

엔티티 조회

  • 엔티티를 조회해 그대로 반환: V1
    (엔티티 스펙이 변해버리면 API 스펙 자체도 변하기 때문에 큰일)
  • 엔티티 조회 후 DTO 로 변환: V2
    (API 스펙 딱 맞게 Controller 단에서 DTO로 변환해 반환해야 함)
  • 페치 조인으로 쿼리 수 최적화: V3
    (그럼 성능이 잘 안나올 수 있는데 그렇다면 fetch join 사용)
  • 컬렉션 페이징과 한계 돌파: V3.1
    (실무에서는 페이징 쓸 일이 상당히 많음)
    - 컬렉션은 페치조인시 페이징이 불가능
    - xToOne 관계는 페치 조인으로 쿼리 수 최적화
    - 컬렉션은 페치 조인 대신 지연로딩을 유지하고 hibernate.dafault_batch_fetch_size옵션을 주거나, @BatchSize로 최적화

DTO 직접 조회

  • JPA에서 DTO를 직접 조회: V4
  • 컬렉션 조회 최적화 - 일대다 관계인 컬렉션은 IN 절을 활용해 메모리에 미리 조회해 최적화: V5
    (주문 하나에 주문 상품 2개인 경우 조인하면 뻥튀기가 됨)
  • 플랫 데이터 최적화 - JOIN 결과를 그대로 조회 후 애플리케이션에서 (발라서) 원하는 모양으로 직접 변환: V6

권장하는 순서

  1. 우선 엔티티로 조회하는 방식으로 접근
    1.1. 그 다음 페치 조인으로 쿼리 수를 최적화하기
    1.2. 컬렉션 최적화
    1.2.1. 페이징이 필요하다면 hibernate.dafault_batch_fetch_size(사실상 이 옵션은 default로 넣어주는 것이 좋음), @BatchSize로 최적화
    1.2.2. 페이징이 필요없다면 페치 조인을 사용할지 안할지 알아서 결정하면 됨

  2. 엔티티 조회 방식으로도 해결이 되지 않는다면 DTO 조회 방식 사용

  3. DTO 조회 방식으로도 해결이 안된다면 NativeSQL or 스프링 JdbcTemplate 사용

참고

엔티티 조회 방식은 페치 조인이나 hibernate.dafault_batch_fetch_size, @BatchSize (이 옵션 넣으면 웬만하면 원하는 성능 나옴) 같이 코드를 거의 수정하지 않고, 옵션만 약간 변경해 다양한 성능 최적화를 시도할 수 있다.

반면, DTO를 직접 조회하는 방식은 성능을 최적화 하거나 성능 최적화 방식을 변경할 때 많은 코드를 변경해야 한다.

📌 캐시하는 것은 무조건 DTO로 변환해 DTO를 캐시해야 함. 엔티티를 직접 캐시하면 안됨.

참고

개발자는 성능 최적화와 코드 복잡도 사이 줄타기를 해야한다. (trade off)
항상 그런 것은 아니지만, 보통 성능 최적화는 단순한 코드를 복잡한 코드로 몰고간다.

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

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

DTO 조회 방식의 선택지

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

V4 (단건 조회시 굉장히 유용한 방식)

: 코드가 단순해 직관적이고 명확하다.
특정 주문 한건만 조회하면 이 방식을 사용해도 성능이 잘 나온다. 예를 들어 조회한 Order 데이터가 한 건이라면 OrderItem을 찾기 위한 쿼리도 한 번만 실행하면 된다.

V5 (V4에 비해 코드 복잡, 성능 향상)

: 코드가 복잡하다.
여러 주문을 한꺼번에 조회하는 경우에는 V4 대신 이것을 최적화한 V5 방식을 사용해야 한다. 예를 들어 조회한 Order 데이터가 1000건인데 V4 방식을 그대로 사용하면 쿼리가 총 1+1000번 실행된다.
(여기서 1은 Order를 조회한 쿼리, 1000은 조회된 Order의 row 수)

V5 방식으로 최적화하면 쿼리가 총 1+1번만 실행된다. 상황에 따라 다르겠지만 운영 환경에서 100배 이상의 성능차이가 날 수 있다.

V6 (완전히 다른 접근 방식)

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

profile
윤경
개발 바보 이사 중
이전 포스트

[SpringBoot&JPA] [활용2] ⭐️ API 개발 고급 - 지연 로딩과 조회 성능 최적화

다음 포스트

[SpringBoot&JPA] [활용2] API 개발 고급 - 실무 필수 최적화

0개의 댓글