JPA N + 1문제와 성능 최적화

HyunKyu Lee·2024년 4월 4일

N + 1 문제란?

1개의 쿼리를 날렸을 때 N개의 추가적인 예상치 못한 쿼리가 발생하면서 일어나는 성능저하 문제를 이야기한다.

예시 코드를 위한 프로젝트 구조

중요 변수들만 포함하고 나머지는 생략하였다.
여기서 중요한 부분은 테이블 관계 mapping시에 모두 지연로딩 전략을 걸어줘야 한다는 점이다. 그렇지 않다면 조회하는 순간에 이미 즉시로딩 되어버려 N + 1 문제가 발생하고 최적화의 여지가 사라진다.
주문 조회 로직을 예시로 들어서 N + 1 문제를 확인하고 해결해보도록 하자

Entity -> DTO변환

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

Order정보를 DTO로 조회하여 return하는 controller

OrderDto

@Data
static class OrderDto {
 private Long orderId;
 private String name;
 private LocalDateTime orderDate; //주문시간
 private List<OrderItemDto> orderItems;

 public OrderDto(Order order) {
	 orderId = order.getId();
	 name = order.getMember().getName(); // 쿼리 발생!!
	 orderDate = order.getOrderDate();
	 orderItems = order.getOrderItems().stream()
	 .map(orderItem -> new OrderItemDto(orderItem)).collect(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();
 }
}

해당 API를 요청한다면 너무 많은 SQL이 실행되는 것을 확인할 수 있다.
SQL 실행 수
- order 1번
- member N번(order 조회 수 만큼)
- orderItem N번(order 조회 수 만큼)
- item N번(orderItem 조회 수 만큼)

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

Entity -> DTO변환 Fetch Join 최적화

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

OrderRepository에 추가

public List<Order> findAllWithItem() {
	 return em.createQuery(
	 "select distinct o from Order o" +
	 " join fetch o.member m" +
	 " join fetch o.orderItems oi" +
	 " join fetch oi.item i", Order.class)
	 .getResultList();
}

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

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

Entity -> DTO변환 - 페이징 문제 해결

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

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

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

Controller


/**
 *   엔티티를 조회해서 DTO로 변환 페이징 고려
 * - ToOne 관계만 우선 모두 페치 조인으로 최적화
 * - 컬렉션 관계는 hibernate.default_batch_fetch_size, @BatchSize로 최적화
 */
@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.findAllWithMember(offset, limit);
 List<OrderDto> result = orders.stream()
 .map(o -> new OrderDto(o))
 .collect(toList());
 return result;
}

OrderRepository에 추가

public List<Order> findAllWithMember(int offset, int limit) {
	 return em.createQuery(
	 "select o from Order o" +
	 " join fetch o.member m", Order.class)
	 .setFirstResult(offset)
	 .setMaxResults(limit)
	 .getResultList();
}

최적화 옵션

spring:
 jpa:
	 properties:
		 hibernate:
			 default_batch_fetch_size: 1000

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

쿼리 결과

다음과 같은 DB 데이터 상황에서 총 3번의 쿼리가 나간다.
1. orders table조회 (member와 join해서 같이 조회함)
2. order_item table조회 select * from order_item ... where order_id in (?, ?) -> 이런식의 쿼리 생성
3. item table 조회 select * from item ... where itemId in (?, ?, ?, ?) -> 이런식의 쿼리 생성

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

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

JPA에서 DTO 직접 조회

DTO 직접조회 (쿼리 최적화 전)

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

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

JPA에서 DTO 직접 조회 - 컬렉션 조회 최적화

위의 방식과 같이 조회하면 역시나 N + 1 문제가 발생한다.

/**
 * 최적화
 * Query: 루트 1번, 컬렉션 1번
 * 데이터를 한꺼번에 처리할 때 많이 사용하는 방식
 *
 */
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 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 in :orderIds", OrderItemQueryDto.class)
 .setParameter("orderIds", orderIds)
 .getResultList();
 return orderItems.stream()
 .collect(Collectors.groupingBy(OrderItemQueryDto::getOrderId));
}

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

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

public List<OrderFlatDto> findAllByDto_flat() {
        return em.createQuery(
                        "select new jpabook.jpashop.repository.order.query.OrderFlatDto(o.id, m.name, o.orderDate, o.status, i.name, oi.orderPrice,oi.count)" +
                                " from Order o" +
                                " join o.member m" +
                                " 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 OrderStatus orderStatus;
 private String itemName;//상품 명
 private int orderPrice; //주문 가격
 private int count; //주문 수량

 public OrderFlatDto(Long orderId, String name, LocalDateTime orderDate,
OrderStatus orderStatus, String itemName, int orderPrice, int count) {
	 this.orderId = orderId;
	 this.name = name;
	 this.orderDate = orderDate;
	 this.orderStatus = orderStatus;
	 this.itemName = itemName;
	 this.orderPrice = orderPrice;
	 this.count = count;
 }
}

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