[JPA] JPA의 성능 최적화

 

 

 

 

 

JPA에서 성능 최적화를 하기 위한 몇가지 방법들을 알아보도록 하겠습니다.

 

 

 

 

 

 

 

모든 연관관계는 지연로딩

모든 연관관계는 FetchType.LAZY를 통한 지연로딩으로 설정해 주시는 것을 권장합니다.

 

즉시 로딩을 사용할 경우 예상하지 못한 쿼리가 발생할 수 있으며, 이는 최적화를 방해하는 요소가 됩니다.

 

 

 

 

 

 

 

 

 

 

 

 

 

XToOne 관계

페치 조인을 사용합니다.

 

ToOne 관계를 모두 지연 로딩으로 설정한 이후, 조회하는 시점에 페치 조인을 통해 조회하는 것으로 성능을 향상시킬 수 있습니다.

 

ToOne 관계는 조회 시 row수를 증가시키지 않기 때문에, 아무런 문제 없이 페이징도 가능합니다.

 

쿼리를 작성할 때에는 엔티티로 조회하는 방법과,  DTO로 바로 조회하는 방법을 선택할 수 있습니다.

 

성능을 극한으로 끌어올리려는 것이 아닌 이상, 엔티티로 조회하는 것을 권장합니다.

(화면에 의존적이지 않으며, 범용적이며 쿼리를 작성하기도 훨씬 쉽습니다.)

 

 

 

 

 

 

엔티티로 조회하는 방법

em.createQuery("select o from Order o join fetch o.member m join fetch o.delivery d", 
Order.class)
.getResultList();

 

 

 

 

 

DTO로 조회하는 방법

em.createQuery(
    "select new jpabook.jpashop.repository.OrderSimpleQueryDto(o.id, o.name, o.orderDate) " + 
    "from Order o "+
    "join fetch o.member m "+
    "join fetch o.delivery d",
    OrderSimpleQueryDto.class)
    .getResultList();

패키지 명까지 다 적어주어야 합니다.

(쿼리 DSL을 사용하면 좀 더 간편하게 사용할 수 있습니다.)

 

 

 

 

 

 

 

 

가이드

• 우선 엔티티를 DTO로 변환하는 방법을 선택합니다.
• 필요하면 페치 조인으로 성능을 최적화 합니다. (대부분의 성능 문제가 해결됩니다.)
• 그래도 성능 최적화가 필요하다면 DTO로 직접 조회하는 방법을 사용합니다.
• 최후의 방법으로는 JPA가 제공하는 네이티브 SQL이나 스프링 JDBC Template를 사용해서 SQL을 직접 사용할 수 있습니다.

 

 

 

 

 

 

 

 

 

 

 

 

 

 

XToMany 관계

ToOne 관계는 페치 조인을,
컬렉션은 default_batch_fetch_size(BatchSize)를 사용합니다.

 

default_batch_fetch_size는 글로벌한 설정이며, @BatchSize는 엔티티별로 최적화 하는 방법입니다.

 

그러나 대부분의 경우 글로벌한 설정만으로 충분합니다.

 

 

 

 

 

 

배치 사이즈가 이상하게 작동한다면

https://www.inflearn.com/questions/34469

default_batch_fetch_size 관련질문 - 인프런 | 질문 & 답변

 

 

 

 

 

 

 

 

 

 

 

컬렉션을 DTO로 조회하는 경우

컬렉션을 DTO로 바로 조회하는 것은 배치사이즈를 적용할 수 없습니다.

 

이런 경우 직접 IN 쿼리를 작성하여 해결합니다.

 

public class OrderQueryDto {
    private Long orderId;
    private String name;
    private Address address;
    private List<OrderItemQueryDto> orderItems;

    public OrderQueryDto(Long orderId, String name, Address address){
          this.orderId = orderId;
          this.name= name;
          this.address= address;
     }
}

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


}

 

 

 

 

//findOrders()
em.createQuery(
              "select new ~~~.OrderQueryDto(o.id, m.name, d.address)" +
              " from Order o" +
              " join o.member m" +
              " join o.delivery d", OrderQueryDto.class).getResultList();
)

 

 

 

 

 

 

 

 

최적화 적용 전

//findOrderItems()
em.createQuery(
          "select .~~~.OrderItemQueryDto(oi.order.id,o.itemName, m.orderPrice, d.count)" +
          " from OrderItem oi" +
          " join oi.item i" +
          " where oi.order.id =: orderId", OrderItemQueryDto.class)
       .setParameter("orderId",orderId)
      .getResultList();
)

 

List<OrderQueryDto> result = findOrders();

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

루트를 조회하는 쿼리는 1번, 컬렉션을 조회하는 쿼리는 N번 수행되었습니다. (N+1 발생)

 

 

 

 

 

최적화 적용

//findOrderItems()
em.createQuery(
          "select new japbook.~~~.OrderItemQueryDto(oi.order.id,o.itemName, m.orderPrice, d.count)" +
          " from OrderItem oi" +
          " join oi.item i" +
          " where oi.order.id in :orderIds", OrderItemQueryDto.class)       //In으로 변경
       .setParameter("orderIds",orderIds)
      .getResultList();
)

 

List<OrderQueryDto> result = findOrders();//쿼리1번

List<Long> orderIds = result.stream()
                    .map( o -> o.getOrderId())
                    .toList():

List<OrderItemQueryDto> orderItems = findOrderItems(orderIds);//쿼리1번


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

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

쿼리가 총 2번이 발생합니다.

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

정리

 

엔티티 조회 시

• 컬렉션은 페치 조인 시 페이징이 불가능합니다.
• 따라서 ToOne관계는 페치 조인으로 쿼리 수를 최적화 합니다.
• 이후 컬렉션은 페치 조인 대신에 지연 로딩으로 유지 후, default_batch_fetch_size 혹은 @BatchSize로 최적화합니다.

 

 

DTO 직접 조회 시

• DTO로 조회 시 컬렉션은 IN절을 활용해서 메모리에 미리 조회해서 최적화합니다.

 

 

 

권장 순서

1. 엔티티 조회 방식으로 우선 접근합니다.
   1. 페치조인으로 쿼리 수를 최적화합니다
   2. 컬렉션을 최적화하는 방법으로는 다음을 사용합니다.
      1. 페이징 필요한 경우:  배치사이즈 옵션
      2. 페이징이 필요 없는 경우: 페치 조인을 사용합니다(단 2개 이상은 사용하면 안됩니다.)
2. 엔티티 조회 방식으로 해결이 안된다면 DTO 조회 방식을 사용합니다.
3. DTO 조회 방식으로도 해결이 안되면 NatviceSQL 또는 JdbcTemplate사용합니다.

 

 

 

 

 

 

 

 

 

 

 

 

 

마무리

위의 방법으로도 성능이 안나온다면 캐시를 사용하던가 하는 다른 방법을 찾아야 합니다.

앞으로 공부할 내용이지만, 엔티티는 절대 캐시를 하면 안됩니다.

 

영속성 컨텍스트와 캐시가 엉켜서 오류를 발생시킬 수 있기 때문입니다.

캐시를 할 때에는 DTO로 변환하여 캐시를 하여야 합니다.

(엔티티를 캐시하는 2차캐시가 있긴 하지만, 이는 실제로 사용하기 너무 까다롭다고 합니다.)

 

 

 

 

 

 

 

 

 

 

 

Reference

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