[스프링부트 API 개발] API 개발 2 - DTO로 데이터 전달하기, 지연 로딩, 컬렉션 최적화

[인프런] 김영한님의 실전 스프링부트와 JPA 활용 2편을 수강하면서 공부한 내용을 바탕으로 작성하였습니다.

---

API 개발 중 요청 값과 응답 값을 DTO로 주고받는 방법과 지연 로딩 최적화에 대해 작성한 글입니다.

[스프링부트 API 개발] API 개발 1 - DTO로 데이터 전달하기, 지연 로딩, 컬렉션 최적화

[Spring Framework/JPA] - [스프링부트 API 개발] API 개발 1 - DTO로 데이터 전달하기, 지연 로딩, 컬렉션 최적화

 

 

---

컬렉션 조회 최적화하기

주문내역에서 추가로 주문한 상품 정보(1:N)를 추가로 조회하는 경우 Order 기준으로 컬렉션인 OrderItem과 Item이 필요합니다.

 

컬렉션인 일대다 관계 (OneToMany) 를 조회하는 방법으로는 다음과 같은 방법이 있습니다.

 

(1) 엔티티 직접 노출하기 - 지연로딩 초기화

 

(2) 엔티티를 DTO로 변환 - 지연로딩 초기화

 

(3) 엔티티를 DTO로 변환 - 모두 FETCH JOIN 적용하기 (페이징 X)

 

(3.2)  엔티티를 DTO로 변환 - XToOne 관계는 Fetch Join 적용, 일대다 관계는 batch_fetch_size로 최적화하기 (페이징 O)

 

(4) JPA에서 DTO로 바로 조회하기 - 컬렉션 N번 조회 ( 1 + N Query)

 

(5) JPA에서 DTO로 바로 조회하기 - 컬렉션 1번 조회 ( 1 + 1 Query)

 

(1) 엔티티 직접 노출하기 - 지연로딩 초기화 (비추!!)

@GetMapping("/api/v1/orders")
     public List<Order> ordersV1() {
         List<Order> all = orderRepository.findAllByString(new OrderSearch());

         for (Order order : all) {
             order.getMember().getName(); //Lazy 강제 초기화
             order.getDelivery().getAddress(); //Lazy 강제 초기화
             List<OrderItem> orderItems = order.getOrderItems();
             orderItems.stream().forEach(o -> o.getItem().getName()); //Lazy 강제 초기화
         }
         return all;
 }

FetchType.LAZY로 연결된 지연 로딩을 모두 강제 초기화 하여 반환하는 방식입니다.

 

✔ 엔티티를 외부에 직접 노출하므로 좋지 않습니다.

✔ 엔티티로 조회하는 경우 양방향 연관관계면 무한 루프에 걸리지 않도록 @JsonIgnore를 추가해야 합니다.

 

(2) 엔티티를 DTO로 변환 - 지연로딩 초기화 (비추)

 

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

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

1번과 같이 FetchType.LAZY로 연결된 지연 로딩을 모두 강제 초기화 하여 반환하는 방식입니다. 

 

✔ 지연 로딩으로 너무 많은 SQL을 실행하는 단점이 있습니다.

✔ SQL 실행 수

* Order 1번

* member, delivery N번 (Order 조회 수만큼)

* orderItem N번 (Order 조회 수만큼)

* item M번 (OrderItem 조회 수만큼)

 

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

 

(3) 엔티티를 DTO로 변환 - 모두 FETCH JOIN 적용하기 (페이징 X) (비추)

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

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를 사용하여 order가 컬렉션 페치 조인 때문에 중복 조회되는 것을 막아줍니다.

 

* 일대다 조인으로 데이터베이스 row가 증가한다. 같은 order 엔티티의 조회 수도 증가하게 됩니다.

JPA의 distinct를 통해 (1) SQL에 distinct를 추가하고, (2) 같은 엔티티가 조회되면 애플리케이션에서 중복을 걸러줍니다.

 

단점:

1:N, N:1, 1:1 관계를 모두 페치 조인을 하게 되면 페이징을 할 수 없습니다.

또한 컬렉션 페치 조인은 1개만 사용할 수 있는 단점도 있습니다.  

 

(3.2)  엔티티를 DTO로 변환 - XToOne 관계는 Fetch Join 적용, 일대다 관계는 batch_fetch_size로 최적화하기 (페이징 O) (추천!!)

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

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

 

// 컬렉션 최적화 옵션 : size 크기는 100 ~ 1000이 적당합니다.
spring:
  jpa:
    properties:
 	  hibernate:
 	    default_batch_fetch_size: 1000

 

장점

✔ Query 호출 수가 1 + N => 1 + 1로 최적화됩니다.

✔ 조인보다 DB 데이터 전송량이 최적화됩니다.

(Order와 OrderItem을 조인하면 Order가 OrderItem 만큼 중복해서 조회됩니다.

이 방법은 각각 조회하므로 전송해야 할 중복 데이터가 없습니다.)

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

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

 

 

결론

✔ ToOne 관계는 페치 조인해도 페이징에 영향을 주지 않는다.

따라서 ToOne 관계는 페치조인으로 쿼리 수를 줄여 해결하고, 나머지 hibernate.default_batch_fetch_size 로 최적화하는 방식을 이용하자.

 

(4) JPA에서 DTO로 바로 조회하기 - 컬렉션 N번 조회 ( 1 + N Query)

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

public List<OrderQueryDto> findOrderQueryDtos() {

     //루트 조회(toOne 코드를 모두 한번에 조회) - Query 1
     List<OrderQueryDto> result = findOrders();
     
     //루프를 돌면서 컬렉션 추가(추가 쿼리 실행) - Query N
     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, d.address)" +
         " from Order o" +
         " join o.member m" +
         " join o.delivery d", 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();
     }
}

 

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


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

 

✔ Query: 루트 1번, 컬렉션 N 번 실행 ToOne(N:1, 1:1) 관계들을 먼저 조회하고, ToMany(1:N) 관계는 각각 별도로 처리합니다.

 

=> ToOne 관계는 조인해도 데이터 row 수가 증가하지 않는다. ToMany(1:N) 관계는 조인하면 row 수가 증가한다.

row 수가 증가하지 않는 ToOne 관계는 조인으로 최적화하기 쉬우므로 한번에 조회하고,

ToMany 관계는 최적화 하기 어려우므로 findOrderItems() 같은 별도의 메서드로 조회합니다.

 

(5) JPA에서 DTO로 바로 조회하기 - 컬렉션 1번 조회 ( 1 + 1 Query)

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

/**
 * 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;
}

// Order의 id 값 컬렉션에 모으기
private List<Long> toOrderIds(List<OrderQueryDto> result) {
     return result.stream()
             .map(o -> o.getOrderId())
             .collect(Collectors.toList());
}

// 조회한 orderId로 ToMany 관계인 OrderItem을 한꺼번에 조회한다. (in 사용)
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))