컬렉션인 일대다 관계(OneToMany) 를 조회하고, 최적화하는 방법을 알아보자.
주문 조회 V1: 엔티티 직접 노출
@RestController
@RequiredArgsConstructor
public class OrderApiController {
private final OrderRepository orderRepository;
/**
* V1. 엔티티 직접 노출
* - Hibernate5Module 모듈 등록, LAZY=null 처리
* - 양방향 관계 문제 발생 -> @JsonIgnore
*/
@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;
}
}
orderItem , item 관계를 직접 초기화하면 Hibernate5Module 설정에 의해 엔티티를 JSON으로 생성한다.
양방향 연관관계면 무한 루프에 걸리지 않게 한곳에 @JsonIgnore 를 추가해야 한다.
엔티티를 직접 노출하므로 좋은 방법은 아니다.
주문 조회 V2: 엔티티를 DTO로 변환
Order또한 DTO로, Order안에있는 OrderItem 또한 DTO로 변환시켜줘야한다.
엔티티를 가지지않게 전부 DTO로 변환
값타입은 그냥 사용해도된다.
@GetMapping("/api/v2/orders")
public List<OrderDto> ordersV2() {
List<Order> orders = orderRepository.findAllByString(new OrderSearch());
return orders.stream().map(m -> new OrderDto(m)).collect(Collectors.toList());
}
@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(Collectors.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();
}
}
지연 로딩으로 너무 많은 SQL 실행
SQL 실행 수
order 1번 member ,
address N번(order 조회 수 만큼)
orderItem N번(order 조회 수 만큼)
item N번(orderItem 조회 수 만큼)
[ 엔티티를 DTO로 변환하는 과정에서 프록시 초기화가 일어나고, 그때 쿼리가 많이 발생 ]
참고
지연 로딩은 영속성 컨텍스트에 있으면 영속성 컨텍스트에 있는 엔티티를 사용하고 없으면 SQL을 실행한다.
따라서 같은 영속성 컨텍스트에서 이미 로딩한 회원 엔티티를 추가로 조회하면 SQL을 실행하지 않는다.
주문 조회 V3: 엔티티를 DTO로 변환 - 페치 조인 최적화
@GetMapping("/api/v3/orders")
public List<OrderDto> ordersV3() {
List<Order> orders = orderRepository.findAllWithItem();
return orders.stream().map(m -> new OrderDto(m)).collect(Collectors.toList());
}
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();
}[Order와 orderItem은 일다대 이므로 distinct를 사용해야한다.]
페치 조인으로 SQL이 1번만 실행됨 [ fetch join 사용으로 인해 V2의 N +1 문제를 해결했다. ]
distinct 를 사용한 이유는 일대다 조인이 있으므로 데이터베이스 row가 증가한다.
그 결과 같은 order 엔티티 의 조회 수도 증가하게 된다.
JPA의 distinct는 SQL에 distinct를 추가하고, 같은 엔티티가 조회되면, 애플리케이션에서 중복을 걸러준다.
[sql에 distinct를 붙여주는것만으로는 중복엔티티제거가 되지않는다.]
이 예제에서 order가 컬렉션 페치 조인 때문에 중복 조회 되는 것을 막아준다.
단점 -> 페이징 불가능 [ 일대다 연관관계가 있게끔 조인 sql를 생성하면 페이징 불가능-> 위의 예제에서는 Order와 OrderItem은 일다대 연관관계이므로 둘이 join했을경우 페이징은 불가능하다, 멤버나 딜리버리과 같은 다대일 관계에서는 상관없다. ]
[ row가 증가하기때문에 생각과 다른 결과가 나오기 때문이다. 페이징 하려고하면 hibernate가 경고를 하고 메모리상에서 페이징을 진행해주기는 하지만 사용하면 안된다.]
fetch join 시 별칭관련 질문입니다 - 인프런
안녕하세요 영한님 기다리던 2편도 어제부터 너무 즐겁게 보고 있습니다 항상 좋은 강의 감사드립니다 테스트 코드 작성 중 2가지 질문이 있어 질문 드립니다 기본편 패치조인 한계편 초반에 보
www.inflearn.com
별칭을 쓸수있게 hibernate가 지원하지만 별칭을 이용하여 on,where등에서 필터링을 진행하면 안된다.
하지만 위의 v3 방식은
distinct로 인해 jpa가 엔티티 중복을 제거해준다고 하지만
실제 DB에서는 일대다 조인으로 인해 데이터가 증가(뻥튀기)한 결과 그대로 어플리케이션으로 보내기때문에 많은 용량?이 필요하다고 한다.
일단 쿼리 결과를 어플리케이션에서 받아서 중복제거 처리를 해야하므로 리소스가 많이 사용될거같긴하다.
[데이터 전송량이 높다.]
v3.1에서 일대다가 아닌 연관관계만 fetch join해서 데이터 증가(뻥튀기)를 없애고 진행하는 방법을 보여준다.
주문 조회 V3.1: 엔티티를 DTO로 변환 - 페이징과 한계 돌파
컬렉션을 페치 조인하면 페이징이 불가능하다.
[ 여기서 컬렉션은 일대다 연관관계를 말한다.
예시로 Order엔티티가 orderItem리스트 필드를 가지고있고, fetch join으로 OrderItem을 하면 페이징이 불가능하다.]
컬렉션을 페치 조인하면 일대다 조인이 발생하므로 데이터가 예측할 수 없이 증가한다.
[ 팀과 멤버를 조인하고 팀을 조회하면 해당 팀에 포함된 멤버수만큼 데이터가 늘어난다.]
일다대에서 일(1)을 기준으로 페이징을 하는 것이 목적이다. 그런데 데이터는 다(N)를 기준으로 row가 생성된다.
Order를 기준으로 페이징 하고 싶은데, 다(N)인 OrderItem을 조인하면 OrderItem이 기준이 되어버린다.
(더 자세한 내용은 자바 ORM 표준 JPA 프로그래밍 - 페치 조인 한계 참조)
이 경우 하이버네이트는 경고 로그를 남기고 모든 DB 데이터를 읽어서 메모리에서 페이징을 시도한다.
최악의 경우 장애로 이어질 수 있다
그러면 페이징 + 컬렉션 엔티티를 함께 조회하려면 어떻게 해야할까?
지금부터 코드도 단순하고, 성능 최적화도 보장하는 매우 강력한 방법을 소개하겠다.
대부분의 페이징 + 컬렉션 엔티티 조회 문제는 이 방법으로 해결할 수 있다.
1. 먼저 ToOne(OneToOne, ManyToOne) 관계를 모두 페치조인 한다.
ToOne 관계는 row수를 증가시키지 않으므로 페이징 쿼리에 영향을 주지 않는다.
[ 위에 예시에서는 member와 delivery는 다대일,일대일 연관관계이므로 페이징에 영향을 주지않는다.]
orderItem와 그것과 연관된 Item은 fetch join 제외한다.
2. 컬렉션은 지연 로딩으로 조회한다
3. 지연 로딩 성능 최적화를 위해 hibernate.default_batch_fetch_size , @BatchSize 를 적용한다.
hibernate.default_batch_fetch_size: 글로벌 설정
jpa:
properties:
hibernate:
default_batch_fetch_size: 1000 #최적화 옵션@BatchSize: 개별 최적화 [개별로 설정하려면 해당 어노테이션을, 전역설정하려면 위의 설정을 사용 ]
이 옵션을 사용하면 컬렉션이나, 프록시 객체를 한꺼번에 설정한 size 만큼 IN 쿼리로 조회한다.
설정한 size만큼 데이터를 가져온다.
사이즈를 10이라하고 가져올 총 데이터가 100개라면
in 쿼리로 10개씩 가져오고, 필요할때마다 또 10개씩 가져온다.
/**
* V3.1 엔티티를 조회해서 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.findAllWithMemberDelivery(offset, limit);
List<OrderDto> result = orders.stream()
.map(o -> new OrderDto(o))
.collect(Collectors.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();
}
fetch join으로 설정해둔 멤버와 딜리버리는 join으로 한번에 가져오고
List<OrderDto> result = orders.stream()
.map(o -> new OrderDto(o))
.collect(Collectors.toList());이 부분으로 인해 LAZY 로딩된 OrderITEM과 OrderItem 의 Item 이 프록시 초기화 [ LAZY 초기화]가 된다.
in 쿼리로 진행하며
기본키는 인덱싱 되어있으므로 속도가 빠르다.
in으로 해당되는 모든 데이터를 가져오므로 매번 orderitem쿼리를 실행하지않고 단 한번에 필요한 orderitem을 가져올 수 있다. [ 배치 사이즈만큼 가져온다.]
그리고 그 orderitem의 item 또한 in쿼리로 한번에 batch size만큼 가져온다.
[ 가져올 로우 수 == batch size ]
batch size만큼 가져온것 이후의 데이터가 필요하면 다시한번 batch size만큼 가져온다.
batch size설정을 하지않았다면
lazy 초기화할때 orderitem을 가져오고 해당 orderitem의 item들을 또 각각 쿼리로 가져오므로
1 + n + m 의 쿼리가 발생한다.
batch size를 설정한 후
1 + 1 + 1 로 쿼리가 줄어든 모습을 확인할 수 있다.
[
오더를 조회하는 쿼리 1번 [결과 2개]
+
각 오더의 오더아이템을 가져오는 쿼리 1번 [ ?가 2개]
+
각 오더 아이템의 포함된 아이템들을 가져오는 쿼리 1번 [?개 4개]
]
?를 이용하여 한번에 가져오므로 아래와 같은 결과를 위한 데이터를 쉽게 가져올수있었다.
물론 batch size보다 더 많은 데이터를 가져와야한다면 다시한번 쿼리가 나가기 때문에
쿼리수는 증가할수있다. 하지만 batch size를 가져와야하는 총 데이터 갯수보다 크게 잡는다면
쿼리는 1번 나간다.
이정도 최적화하면 원하는성능이 나온다.
하지만 고객 실시간정보를 받아서 처리해야하는 작업이 있다면 레디스 캐시같은것을 사용해야한다.
V3와는 다르게 일대다 연관관계인 엔티티와는 fetch join을 하지않기에
데이터가 증가(뻥튀기)되지않는다. [ 그래서 distinct또한 필요없다.]
그러므로 실제 DB의 쿼리 결과는 데이터가 증가되지않은 결과가 나온다.
그래서 데이터 전송량이 V3와 비교해서 적다.
[데이터 중복이없다.]
페이징을 써야한다면 v3.1 방식을 써야할수밖에없고,
그게아니고 조회라면
데이터전송량이 증가가있지만 쿼리한번에 가져올수있는 v3 방식을 사용할지
데이터전송량이 적고, 쿼리는 몇번 더 증가하게되는 v3.1 방식을 사용할지는
트레이드오프가 있다.
그리고
xToOne [ ManyToOne,OneToOne] 관계에서는
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();
}에서
public List<Order> findAllWithMemberDelivery(int offset, int limit) {
return em.createQuery(
"select o from Order o", Order.class)
.setFirstResult(offset)
.setMaxResults(limit)
.getResultList();
}다음과 같이 페치 조인부분을 생략해도 된다.
배치사이즈 설정이 되어있으므로, 멤버,딜리버리,오더아이템,아이템 LAZY 초기화[프록시 초기화]가 될때
in 쿼리로 인해 한번에 가져와진다.
즉
오더를 가져오는 쿼리 1번
멤버를 가져오는 쿼리 1번
딜리버리를 가져오는 쿼리 1번
오더아이템을 가져오는 쿼리 1번
아이템을 가져오는 쿼리 1번
총 5번의 쿼리가 진행된다.
원래는 fetch join으로 딜리버리와 멤버를 한번에 가져왔었는데, 이번에는 join부분을 없앴으니까
딜리버리,멤버를 가져오는 각각 쿼리때문에 실행할 쿼리가 2번 증가했을뿐이다
batch 설정을 해두어서 in쿼리 덕분에 1번만 실행하면 됬지만
batch 설정을 하지않았다면
각각 n번씩 쿼리가 증가했을것이다.
아무래도 쿼리가 증가하므로 xToOne은 fetch join을 사용하자
[ xToMany와는 다르게 데이터가 증가(뻥튀기==중복데이터추가)되지 않으므로]
전역설정이 아닌 디테일하게 설정하고싶다면
해당 엔티티의 컬렉션필드에 가서 @BatchSize 어노테이션을 붙여준다.
@BatchSize(size = 1000)
@OneToMany(mappedBy = "order", cascade = CascadeType.ALL)
private List<OrderItem> orderItems = new ArrayList<>();컬렉션인 경우는 다음과 같이 필드에 적용하면되지만
@BatchSize(size = 1000)
public abstract class Item {
컬렉션이 아닌경우는
엔티티 클래스레벨에 붙여주면된다.
[오더아이템의 아이템은 ManyToOne 관계이므로 컬렉션이 아니다.]
주로 전역설정을 활용한다고 한다.
장점
쿼리 호출 수가 1 + N -> 1 + 1 로 최적화 된다.
조인보다 DB 데이터 전송량이 최적화 된다.
(Order와 OrderItem을 조인하면 Order가 OrderItem 만큼 중복해서 조회된다.
이 방법은 각각 조회하므로 전송해야할 중복 데이터가 없다.)
페치 조인 방식과 비교해서 쿼리 호출 수가 약간 증가하지만, DB 데이터 전송량이 감소한다.
컬렉션 페치 조인은 페이징이 불가능 하지만 이 방법은 페이징이 가능하다.
결론
ToOne 관계는 페치 조인해도 페이징에 영향을 주지 않는다.
따라서 ToOne 관계는 페치조인으로 쿼리수 를 줄이고 해결하고,
나머지[컬렉션==xToMany연관관계]는 hibernate.default_batch_fetch_size 로 최적화 하자.
참고
default_batch_fetch_size 의 크기는 적당한 사이즈를 골라야 하는데, 100~1000 사이를 선택하는 것을 권장한다.
이 전략을 SQL IN 절을 사용하는데, 데이터베이스에 따라 IN 절 파라미터를 1000으로 제한하기도 한다.
1000으로 잡으면 한번에 1000개를 DB에서 애플리케이션에 불러오므로 DB에 순간 부하가 증가할 수 있다.
하지만 애플리케이션은 100이든 1000이든 결국 전체 데이터를 로딩해야 하므로 메모리 사용량이 같다.
1000으로 설정하는 것이 성능상 가장 좋지만,
결국 DB든 애플리케이션이든 순간 부하를 어디까지 견딜 수 있는지로 결정하면 된다.
참고 - 스프링 부트 3.1 - 하이버네이트 6.2 변경사항 - array_contains
스프링 부트 3.1 부터는 하이버네이트 6.2를 사용한다.
하이버네이트 6.2 부터는 where in 대신에 array_contains 를 사용한다.
where in 사용 문법
where item.item_id in(?,?,?,?)array_contains 사용 문법
where array_contains(?,item.item_id)
참고로 where in 에서 array_contains 를 사용하도록 변경해도 결과는 완전히 동일하다.
그런데 이렇게 변경한 이유는 성능 최적화 때문이다.
select ... where item.item_id in(?)이러한 SQL을 실행할 때 데이터베이스는 SQL 구문을 이해하기 위해 SQL을 파싱하고 분석하는 등
여러가지 복잡한 일을 처리해야 한다.
그래서 성능을 최적화하기 위해 이미 실행된 SQL 구문은 파싱된 결과를 내부에 캐싱하고 있다
이렇게 해두면 이후에 같은 모양의 SQL이 실행되어도 이미 파싱된 결과를 그대로 사용해서 성능을 최적화 할 수 있다.
참고로 여기서 말하는 캐싱은 SQL 구문 자체를 캐싱한다는 뜻이지 SQL의 실행 결과를 캐싱한다는 뜻이 아니다.
SQL 구문 차제를 캐싱하기 때문에 여기서 ? 에 바인딩 되는 데이터는 변경되어도 캐싱된 SQL 결과를
그대로 사용할 수 있다.
그런데 where in 쿼리는 동적으로 데이터가 변하는 것을 넘어서 SQL 구문 자체가 변해버리는 문제가 발생한다.
다음 예시는 in에 들어가는 데이터 숫자에 따라서 총 3개의 SQL구문이 생성된다.
where item.item_id in(?)
where item.item_id in(?,?)
where item.item_id in(?,?,?,?)SQL 입장에서는 ? 로 바인딩 되는 숫자 자체가 다르기 때문에 완전히 다른 SQL이다.
따라서 총 3개의 SQL 구문이 만 들어지고, 캐싱도 3개를 따로 해야한다. 이렇게 되면 성능 관점에서 좋지않다.
array_contains 를 사용하면 이런 문제를 깔끔하게 해결할 수 있다. 이 문법은 결과적으로 where in 과 동일하다. array_contains 은 왼쪽에 배열을 넣는데, 배열에 들어있는 숫자가 오른쪽(item_id)에 있다면 참이된다.
예시) 다음 둘은 같다.
select ... where array_contains([1,2,3],item.item_id)
select ... item.item_id where in(1,2,3)
이 문법은 ?에 바인딩 되는 것이 딱1개 이다.. 배열1개가 들어가는 것이다.
select ... where array_contains(?,item.item_id)
따라서 배열에 들어가는 데이터가 늘어도 SQL 구문 자체가 변하지 않는다. ?에는 배열 하나만 들어가면 된다.
이런 방법을 사용하면 앞서 이야기한 동적으로 늘어나는 SQL 구문을 걱정하지 않아도 된다.
결과적으로 데이터가 동적으로 늘어나도 같은 SQL 구문을 그대로 사용해서 성능을 최적화 할 수 있다.
참고로 array_contains 에서 default_batch_fetch_size 에 맞추어 배열에 null 값을 추가하는데,
이 부분은 아마도 특정 데이터베이스에 따라서 배열의 데이터 숫자가 같아야 최적화가 되기 때문에 그런 것으로 추정된다.
주문 조회 V4: JPA에서 DTO 직접 조회
특정 화면에 fit한 쿼리들은 OrderQueryRepository에서 진행
엔티티 관련한 쿼리는 OrderRepository에서 진행
==> 관심사 분리의 효과, 화면을 위한 API의 라이프사이클과 핵심비즈니스로직[엔티티 관련 쿼리]의 라이프사이클이 다르기때문에 따로 위치시킨다.
@Data
@EqualsAndHashCode(of = "orderId") //orderId 필드만을 기준으로 equals와 hashCode 메소드를 생성 ,이는 orderId가 같으면 동일한 객체로 간주한다는 의미, groupby할때 같은 객체인 기준을 정하기 위해 추가했던것
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;
}
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;
}
}@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;
}
}@JsonIgnore는 JSON 직렬화, 역직렬화에서 속성을 무시하는데 사용된다.
[ json 반환값에서 보이지않고 싶은 필드를 설정하면된다.]
@Repository
@RequiredArgsConstructor
public class OrderQueryRepository {
private final EntityManager em;
/**
* 컬렉션은 별도로 조회
* 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 관계(컬렉션)를 제외한 나머지를 한번에 조회
* OrderQueryDto안의 orderItems는 일대다 연관관계이므로 컬렉션이다. 컬렉션을 제외한 나머지 필드는 쿼리를 이용하여 플랫하게 채우고
* 컬렉션을 채우기 위한 쿼리는 따로 구성한다.
* new를 이용하여 조회한값을 바로 dto에 넣어준다 -> query dsl를 사용하면 개선된다.
*/
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();
}루트 ==기본이 되는 엔티티 == 여기서는 OrderQueryDto
OrderQueryDto안에 OrderItemQueryDto컬렉션이 존재
- Query: 루트 1번, 컬렉션 N 번 실행
- ToOne(N:1, 1:1) 관계들을 먼저 조회하고, ToMany(1:N) 관계는 각각 별도로 처리한다.
이런 방식을 선택한 이유는 다음과 같다.
-ToOne 관계는 조인해도 데이터 row 수가 증가하지 않는다. 그러므로 ToOne 연관관계 엔티티와는 join해서 조회하고 결과를 루트 엔티티에 넣는다.
-ToMany(1:N) 관계는 조인하면 row 수가 증가한다 그래서 따로 쿼리를 실행해서 가져와서 루트 엔티티에 넣는다.
row수가 증가하지 않는 ToOne 관계는 조인으로 최적화 하기 쉬우므로 한번에 조회하고,
ToMany 관계는 최적화 하기 어려우므로 findOrderItems() 같은 별도의 메서드로 조회한다.
주문 조회 V5: JPA에서 DTO 직접 조회 - 컬렉션 조회 최적화
@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 한방에 조회 , in을 이용하여 한번에 가져온다. 원래는 해당 orderid에 맞는거 하나씩 가져오는 쿼리를 반복문으로 반복했음
// orderid리스트를 주고 in 쿼리를 이용하여 쿼리 한번으로 처리
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)); // key는 orderid value는 List<OrderItemQueryDto>인 map으로 변환
}
Query: 루트 1번, 컬렉션 1번
ToOne 관계들을 먼저 조회하고, 여기서 얻은 식별자 orderId로 ToMany 관계인 OrderItem을 한꺼번에 조회
MAP을 사용해서 매칭 성능 향상(O(1))
주문 조회 V6: JPA에서 DTO로 직접 조회, 플랫 데이터 최적화
@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());
}public List<OrderFlatDto> findAllByDto_flat() {
return em.createQuery(
"select new jpabook.jpashop.repository.order.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();
}
Query: 1번
단점
- 쿼리는 한번이지만 조인으로 인해 DB에서 애플리케이션에 전달하는 데이터에 중복 데이터가 추가되므로
상황에 따라 V5 보다 더 느릴 수 도 있다.
- 애플리케이션에서 추가 작업이 크다.
- 페이징 불가능
API 개발 고급 정리
엔티티 조회
- 엔티티를 조회해서 그대로 반환: V1
- 엔티티 조회 후 DTO로 변환: V2
- 페치 조인으로 쿼리 수 최적화: V3
- 컬렉션 페이징과 한계 돌파: V3.1
컬렉션은 페치 조인시 페이징이 불가능
ToOne 관계는 페치 조인으로 쿼리 수 최적화
컬렉션은 페치 조인 대신에 지연 로딩을 유지하고, hibernate.default_batch_fetch_size , @BatchSize 로 최적화
DTO 직접 조회
- JPA에서 DTO를 직접 조회: V4
- 컬렉션 조회 최적화 - 일대다 관계인 컬렉션은 IN 절을 활용해서 메모리에 미리 조회해서 최적화: V5
- 플랫 데이터 최적화 - JOIN 결과를 그대로 조회 후 애플리케이션에서 원하는 모양으로 직접 변환: V6
권장 순서
1.엔티티 조회 방식으로 우선 접근 [ 반환은 DTO ]
1. 페치조인으로 쿼리 수를 최적화
2. 컬렉션 최적화
1. 페이징 필요 hibernate.default_batch_fetch_size , @BatchSize 로 최적화
2. 페이징 필요X 페치 조인 사용
2. 엔티티 조회 방식으로 해결이 안되면 DTO 조회 방식 사용
3. DTO 조회 방식으로 해결이 안되면 NativeSQL or 스프링 JdbcTemplate
엔티티 조회 방식은 페치 조인이나, hibernate.default_batch_fetch_size , @BatchSize 같이 코드를 거의 수정하지 않고,
옵션만 약간 변경해서, 다양한 성능 최적화를 시도할 수 있다.
반면에 DTO를 직접 조회하는 방식은 성능을 최적화 하거나 성능 최적화 방식을 변경할 때 많은 코드를 변경해야 한다.
개발자는 성능 최적화와 코드 복잡도 사이에서 줄타기를 해야 한다.
항상 그런 것은 아니지만, 보통 성능 최적화는 단순한 코드를 복잡한 코드로 몰고간다.
엔티티 조회 방식은 JPA가 많은 부분을 최적화 해주기 때문에, 단순한 코드를 유지하면서, 성능을 최적화 할 수 있다.
반면에 DTO 조회 방식은 SQL을 직접 다루는 것과 유사하기 때문에, 둘 사이에 줄타기를 해야 한다.
[캐싱를 해야하는 경우 엔티티를 캐싱하면 안되고 DTO를 캐싱해야한다. 레디스 또는 로컬 메모리에서 캐싱]
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와 비교해서 성능 차이도 미비하다.
'인프런 > 실전! 스프링 부트와 JPA 활용2 - API 개발과 성능 최적화' 카테고리의 다른 글
| 끝) API 개발 고급 - 실무 필수 최적화 - OSIV (0) | 2024.06.11 |
|---|---|
| 2) API 개발 고급 - 지연 로딩과 조회 성능 최적화 (0) | 2024.06.10 |
| 1) API 개발 기본 [ 회원 등록,수정,조회 API ] (1) | 2024.06.10 |
댓글