JPA JPA를 이용한 API 개발

JPA를 이용한 API 개발

 

JPA 실습 - 1을 업그레이드한 버전이다.

 

실습 - 1에서는 구조만 완성한 상태였고, 실습 - 2에서는 API들을 만들 것이다.

 

1. 기본 API

1 - 1. 회원 등록

@RestController
@RequiredArgsConstructor
public class MemberApiController {
    private final MemberService memberService;
    @PostMapping("/api/v1/members")
    public CreateMemberResponse saveMemberV1(@RequestBody @Valid Member member)
    {
        Long id = memberService.join(member);
        return new CreateMemberResponse(id);
    }
    @Data
    static class CreateMemberRequest {
        private String name;
    }
    @Data
    static class CreateMemberResponse {
        private Long id;
        public CreateMemberResponse(Long id) {
            this.id = id;
        }
    }
}

 

엔티티를 Request Body에 직접 매핑 시 문제점

1. 엔티티에 프레젠테이션 계층을 위한 로직이 추가된다.

 

2. 엔티티에 API 검증을 위한 로직이 들어간다. (@NotEmpty 등등)

 

3. 실무에서는 회원 엔티티를 위한 API가 다양하게 만들어지는데,

한 엔티티에 각각의 API를 위한 모든 요청 요구사항을 담기는 어렵다.

 

4. 엔티티가 변경되면 API 스펙이 변한다.

 

결론

API 요청 스펙에 맞추어 별도의 DTO를 파라미터로 받는다.

 

위 코드를 개선하면 아래처럼 된다.

@PostMapping("/api/v2/members")
public CreateMemberResponse saveMemberV2(@RequestBody @Valid
                                         CreateMemberRequest request) {
    Member member = new Member();
    member.setName(request.getName());
    Long id = memberService.join(member);
    return new CreateMemberResponse(id);
}

 

 

 

 

1 - 2. 회원 수정

수정 API

@PatchMapping("/api/v2/members/{id}")
public UpdateMemberResponse updateMemberV2(@PathVariable("id") Long id,
                                           @RequestBody @Valid UpdateMemberRequest request) {
    memberService.update(id, request.getName());
    Member findMember = memberService.findOne(id);
    return new UpdateMemberResponse(findMember.getId(), findMember.getName());
}

 

MemberService 클래스의 update()

@Transactional
public void update(Long id, String name) {
    Member member = memberRepository.findOne(id);
    member.setName(name);
}

 

데이터를 부분 수정하는 것이라 PUT이 아니라 PATCH 사용

변경 감지를 통해 수정되기 때문에 별도의 update 쿼리를 직접 제작하지 않고,

set메서드를 통해 값만 설정해주고, findOne()메서드로 호출만 해주고 끝난다.

 

 

1 - 3. 회원 조회

@RestController
@RequiredArgsConstructor
public class MemberApiController {
    private final MemberService memberService;
    @GetMapping("/api/v1/members")
    public List<Member> membersV1() {
        return memberService.findMembers();
    }
}

 

문제점

1. 엔티티에 프레젠테이션 계층을 위한 로직이 추가된다.

2. 기본적으로 엔티티의 모든 값이 노출된다.

3. 응답 스펙을 맞추기 위해 로직이 추가된다. (@JsonIgnore, 별도의 뷰 로직 등등)

4. 실무에서는 같은 엔티티에 대해 API가 용도에 따라 다양하게 만들어지는데,

한 엔티티에 각각의 API를 위 한 프레젠테이션 응답 로직을 담기는 어렵다.

5. 엔티티가 변경되면 API 스펙이 변한다.

6. 추가로 컬렉션을 직접 반환하면 항후 API 스펙을 변경하기 어렵다.(별도의 Result 클래스 생성으로 해결)

 

결론

API 응답 스펙에 맞추어 별도의 DTO를 반환한다

 

위 코드를 개선하면 아래처럼 된다.

@GetMapping("/api/v2/members")
public Result membersV2() {
    List<Member> findMembers = memberService.findMembers();
    //엔티티 -> DTO 변환
    List<MemberDto> collect = findMembers.stream()
            .map(m -> new MemberDto(m.getName()))
            .collect(Collectors.toList());
    return new Result(collect);
}
@Data
@AllArgsConstructor
static class Result<T> {
    private T data;
}
@Data
@AllArgsConstructor
static class MemberDto {
    private String name;
}

 

추가로, v1조회를 반환하면

[
  member: {
              ...~~
          }
]

이런 식인데 맨 겉부분이 []라서 배열이다.
이러면 아래처럼 뭔가 추가하고 싶은데 그게 안된다.

[
  temp : {
              ...~~
          }
  member: {
              ...~~
          }
]

근데 v2처럼 하면 맨 겉부분이 {}로 감싸져서 내맘대로 추가할 수 있다는 장점이 있다.

 

 

 

2. 조회용 샘플 데이터

userA는 책 JPA1 BOOK과 JPA2 BOOK를 구매

userB는 책  SPRING1 BOOK과 SPRING2 BOOK를 구매했다.

@Component
@RequiredArgsConstructor
public class InitDb {

    private final InitService initService;

    @PostConstruct
    public void init() {
        initService.dbInit1();
        initService.dbInit2();
    }

//    여기 아래 코드들 싹 다 긁어서 위에 init()에 넣으면 똑같은 거 아닌가??
//    @PostConstruct가 생명주기 이런 것 때문에 @Transactional이 잘 안먹는 문제가 있다고 함
    @Component
    @Transactional
    @RequiredArgsConstructor
    static class InitService {

        private final EntityManager em;

        public void dbInit1() {
            System.out.println("Init1" + this.getClass());
            Member member = createMember("userA", "서울", "1", "1111");
            em.persist(member);

            Book book1 = createBook("JPA1 BOOK", 10000, 100);
            em.persist(book1);

            Book book2 = createBook("JPA2 BOOK", 20000, 100);
            em.persist(book2);

            OrderItem orderItem1 = OrderItem.createOrderItem(book1, 10000, 1);
            OrderItem orderItem2 = OrderItem.createOrderItem(book2, 20000, 2);

            Delivery delivery = createDelivery(member);
            Order order = Order.createOrder(member, delivery, orderItem1, orderItem2);
            em.persist(order);
        }

        public void dbInit2() {
            Member member = createMember("userB", "진주", "2", "2222");
            em.persist(member);

            Book book1 = createBook("SPRING1 BOOK", 20000, 200);
            em.persist(book1);

            Book book2 = createBook("SPRING2 BOOK", 40000, 300);
            em.persist(book2);

            OrderItem orderItem1 = OrderItem.createOrderItem(book1, 20000, 3);
            OrderItem orderItem2 = OrderItem.createOrderItem(book2, 40000, 4);

            Delivery delivery = createDelivery(member);
            Order order = Order.createOrder(member, delivery, orderItem1, orderItem2);
            em.persist(order);
        }

        private Member createMember(String name, String city, String street, String zipcode) {
            Member member = new Member();
            member.setName(name);
            member.setAddress(new Address(city, street, zipcode));
            return member;
        }

        private Book createBook(String name, int price, int stockQuantity) {
            Book book1 = new Book();
            book1.setName(name);
            book1.setPrice(price);
            book1.setStockQuantity(stockQuantity);
            return book1;
        }

        private Delivery createDelivery(Member member) {
            Delivery delivery = new Delivery();
            delivery.setAddress(member.getAddress());
            return delivery;
        }
    }
}

@Component가 붙어서 스프링 빈으로 등록되고,

예전에 스프링 공부할 때 배웠던 @PostConstruct 덕분에 초기화된다.

 

그리고 initService에도 @Component가 붙어 있는데,

내부 클래스는 명시적으로 @Component가 붙어 있어야 스프링 빈으로 등록된다고 한다.

 

 

 

3. 주문 조회 API 개선 과정

먼저 엔티티를 직접 이용

> 엔티티를 DTO로 변환해서 이용

> fetch join으로 최적화

> jpa에서 DTO를 바로 조회

순으로 만들어 보겠다.

 

3 - 1. 엔티티 직접 이용

@RestController
@RequiredArgsConstructor
public class OrderSimpleApiController {
    private final OrderRepository orderRepository;
    /**
     * V1. 엔티티 직접 노출
     * - Hibernate5Module 모듈 등록, LAZY=null 처리
     * - 양방향 관계 문제 발생 -> @JsonIgnore
     */
    @GetMapping("/api/v1/simple-orders")
    public List<Order> ordersV1() {
        List<Order> all = orderRepository.findAllByString(new OrderSearch());
        for (Order order : all) {
            order.getMember().getName(); //Lazy 강제 초기화
            order.getDelivery().getAddress(); //Lazy 강제 초기환
        }
        return all;
    }
}

member 와 delivery 는 지연 로딩이다.

따라서 실제 엔티티 대신에 프록시가 존재한다.

jackson 라이브러리는 기본적으로 이 프록시 객체를 json으로 어떻게 생성해야 하는지 몰라서, 예외가  발생한다.

 

Hibernate5Module 을 스프링 빈으로 등록하면 해결(스프링 부트 사용중)되지만,

그것보다 그냥 DTO를 만들어서 사용하는 것이 더 좋다고 한다.

따라서 방법도 굳이 소개하지는 않겠다.

 

 

3 - 2. DTO로 변환해서 사용

@GetMapping("/api/v2/simple-orders")
public List<SimpleOrderDto> ordersV2() {
    List<Order> orders = orderRepository.findAllByString(new OrderSearch());
    List<SimpleOrderDto> result = orders.stream()
            .map(o -> new SimpleOrderDto(o))
            .collect(toList());
    return result;
}
@Data
static class SimpleOrderDto {
    private Long orderId;
    private String name;
    private LocalDateTime orderDate; //주문시간
    private OrderStatus orderStatus;
    private Address address;
    public SimpleOrderDto(Order order) {
        orderId = order.getId();
        name = order.getMember().getName();
        orderDate = order.getOrderDate();
        orderStatus = order.getStatus();
        address = order.getDelivery().getAddress();
    }
}

엔티티를 DTO로 변환하는 일반적인 방법이다.

쿼리가 총 1 + N + N번 실행된다. (v1과 쿼리수 결과는 같다.)

order 조회 1번(order 조회 결과 수가 N이 된다.)

order -> member 지연 로딩 조회 N 번

order -> delivery 지연 로딩 조회 N 번 예)

order의 결과가 4개면 최악의 경우 1 + 4 + 4번 실행된다.(최악의 경우)

 

지연로딩은 영속성 컨텍스트에서 조회하므로, 이미 조회된 경우 쿼리를 생략한다.

하지만 위험성을 보여주기 위해 최악의 경우를 가져왔다.

 

 

3 - 3. 페치 조인 최적화

@GetMapping("/api/v3/simple-orders")
public List<SimpleOrderDto> ordersV3() {
    List<Order> orders = orderRepository.findAllWithMemberDelivery();
    List<SimpleOrderDto> result = orders.stream()
            .map(o -> new SimpleOrderDto(o))
            .collect(toList());
    return result;
}

OrderRepository에 아래 코드 추가

public List<Order> findAllWithMemberDelivery() {
    return em.createQuery(
                    "select o from Order o" +
                            " join fetch o.member m" +
                            " join fetch o.delivery d", Order.class)
            .getResultList();
}

엔티티를 페치 조인(fetch join)을 사용해서 쿼리 1번에 조회

페치 조인으로 order -> member , order -> delivery 는 이미 조회된 상태이므로 지연로딩X

 

 

3 - 4. JPA에서 DTO를 바로 조회

OrderSimpleApiController - 추가

private final OrderSimpleQueryRepository orderSimpleQueryRepository; //의존관계 주입
/**
 * V4. JPA에서 DTO로 바로 조회
 * - 쿼리 1번 호출
 * - select 절에서 원하는 데이터만 선택해서 조회
 */
@GetMapping("/api/v4/simple-orders")
public List<OrderSimpleQueryDto> ordersV4() {
    return orderSimpleQueryRepository.findOrderDtos();
}

 

OrderSimpleQueryRepository 조회 전용 리포지토리

@Repository
@RequiredArgsConstructor
public class OrderSimpleQueryRepository {
    private final EntityManager em;
    public List<OrderSimpleQueryDto> findOrderDtos() {
        return em.createQuery(
                        "select new 
                        jpabook.jpashop.repository.order.simplequery.OrderSimpleQueryDto(o.id, m.name,
                                o.orderDate, o.status, d.address)" +
                        " from Order o" +
                                " join o.member m" +
                                " join o.delivery d", OrderSimpleQueryDto.class)
                .getResultList();
    }
}

 

OrderSimpleQueryDto 리포지토리에서 DTO 직접 조회

@Data
public class OrderSimpleQueryDto {
    private Long orderId;
    private String name;
    private LocalDateTime orderDate; //주문시간
    private OrderStatus orderStatus;
    private Address address;
    public OrderSimpleQueryDto(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;
    }
}

일반적인 SQL을 사용할 때 처럼 원하는 값을 선택해서 조회

new 명령어를 사용해서 JPQL의 결과를 DTO로 즉시 변환한다.

SELECT 절에서 원하는 데이터를 직접 선택하므로 DB에서 애플리케이션으로 가는 네트웍 용량 최적화(생각보다 미비)

리포지토리 재사용성 떨어짐, API 스펙에 맞춘 코드가 리포지토리에 들어가는 단점

 

 

3 - 5. 정리

엔티티를 DTO로 변환하거나, DTO로 바로 조회하는 두 방법은 각각 장단점이 있다.

둘중 상황에 따라서 더 나은 방법을 선택하면 된다.

엔티티로 조회하면 리포지토리 재사용성도 좋고, 개발도 단순해진다.

 

따라서 권장하는 방법은 다음과 같다.

 

쿼리 방식 선택 권장 순서

1. 우선 엔티티를 DTO로 변환하는 방법을 선택한다.

2. 필요하면 페치 조인으로 성능을 최적화 한다. 대부분의 성능 이슈가 해결된다.

3. 그래도 안되면 DTO로 직접 조회하는 방법을 사용한다.

4. 최후의 방법은 JPA가 제공하는 네이티브 SQL이나 스프링 JDBC Template을 사용해서 SQL을 직접 사용한다.

 

 

 

4. 주문 조회 API 개선 - 컬렉션

3번대 예제에서는 toOne(OneToOne, ManyToOne) 관계만 있었다.

이번에는 컬렉션인 일대다 관계(OneToMany) 를 조회하고, 최적화하는 방법을 알아보자.

 

4 - 1. 엔티티 직접 노출

엔티티를 직접 노출하는 부분은 부정적인 점을 계속 얘기하기도 했고, 특이한 코드도 없어서 이번엔 생략하겠다.

양방향 연관관계일 때 무한루프를 피하기 위해 한곳에 @JsonIgnore 를 추가하는 것만 잊지 말자.

 

 

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

OrderApiController에 아래 코드 추가

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

 

지연 로딩으로 너무 많은 SQL 실행 SQL

실행 수 order 1번

member , address N번(order 조회 수 만큼)

orderItem N번(order 조회 수 만큼)

item N번(orderItem 조회 수 만큼)

 

 

4 - 3. 페치 조인 최적화

OrderApiController에 아래 코드 추가

@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.delivery d" +
                            " 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에서 읽어오고,

메모리에서 페이징 해버린다(매우 위험하다).

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

 

참고

컬렉션 페치 조인은 1개만 사용할 수 있다.

컬렉션 둘 이상에 페치 조인을 사용하면 안된다.

데이터가 부정 합하게 조회될 수 있다.

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

 

 

4 - 4. 페이징과 한계 돌파

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

컬렉션을 페치 조인하면 일대다 조인이 발생하므로 데이터가 예측할 수 없이 증가한다.

 

일다대에서 일(1)을 기준으로 페이징을 하는 것이 목적이다.

그런데 데이터는 다(N)를 기준으로 row가 생 성된다.

 

Order를 기준으로 페이징 하고 싶은데, 다(N)인 OrderItem을 조인하면 OrderItem이 기준이 되어버린다.

(더 자세한 내용은 자바 ORM 표준 JPA 프로그래밍 - 페치 조인 한계 참조)

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

최악의 경우 장애로 이어질 수 있다.

 

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

지금부터 코드도 단순하고, 성능 최적화도 보장하는 매우 강력한 방법을 소개하겠다.

대부분의 페이징 + 컬렉션 엔티티 조회 문제는 이 방법으로 해결할 수 있다.

 

먼저 ToOne(OneToOne, ManyToOne) 관계를 모두 페치조인 한다.

ToOne 관계는 row수를 증가시키지 않으므로 페이징 쿼리에 영향을 주지 않는다.

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

지연 로딩 성능 최적화를 위해 hibernate.default_batch_fetch_size , @BatchSize 를 적용한다.

 

hibernate.default_batch_fetch_size

글로벌 설정

 

@BatchSize

개별 최적화

 

이 옵션들을 사용하면 컬렉션이나, 프록시 객체를 한꺼번에 설정한 size 만큼 IN 쿼리로 조회한다.

 

OrderRepository에 추가

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

 

OrderApiController에 추가

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

 

최적화 옵션

spring:
  jpa:
    properties:
      hibernate:
        default_batch_fetch_size: 1000

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

 

장점

쿼리 호출 수가 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든 애플리케이션이든 순간 부하를 어디까지 견딜 수 있는 지로 결정하면 된다.

 

 

 

4 - 5. JPA에서 DTO 직접 조회

OrderApiController에 추가

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

 

OrderQueryRepository에 추가

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))

 

 

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

OrderApiController에 추가

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

 

OrderQueryDto에 생성자 추가

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

 

OrderQueryRepository에 추가

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

 

OrderFlatDto

@Data
public class OrderFlatDto {
    private Long orderId;
    private String name;
    private LocalDateTime orderDate; //주문시간
    private Address address;
    private OrderStatus orderStatus;
    private String itemName;//상품 명
    private int orderPrice; //주문 가격
    private int count; //주문 수량
    public OrderFlatDto(Long orderId, String name, LocalDateTime orderDate,
                        OrderStatus orderStatus, Address address, String itemName, int orderPrice, int
                                count) {
        this.orderId = orderId;
        this.name = name;
        this.orderDate = orderDate;
        this.orderStatus = orderStatus;
        this.address = address;
        this.itemName = itemName;
        this.orderPrice = orderPrice;
        this.count = count;
    }
}

 

Query는 한번만 사용

 

단점

쿼리는 한번이지만 조인으로 인해 DB에서 애플리케이션에 전달하는 데이터에 중복 데이터가 추가되므로,

상황에 따라 V5 보다 더 느릴 수 도 있다.

애플리케이션에서 추가 작업이 크다.

페이징 불가능

 

 

 

5. 정리

엔티티 조회

엔티티를 조회해서 그대로 반환: V1

엔티티 조회 후 DTO로 변환: V2

페치 조인으로 쿼리 수 최적화: V3

컬렉션 페이징과 한계 돌파: V3.1

    컬렉션은 페치 조인시 페이징이 불가능

    ToOne 관계는 페치 조인으로 쿼리 수 최적화 

    컬렉션은 페치 조인 대신에 지연 로딩을 유지하고, hibernate.default_batch_fetch_size , @BatchSize 로 최적화

 

DTO 직접 조회

JPA에서 DTO를 직접 조회: V4

컬렉션 조회 최적화 - 일대다 관계인 컬렉션은 IN 절을 활용해서 메모리에 미리 조회해서 최적화: V5

플랫 데이터 최적화 - JOIN 결과를 그대로 조회 후 애플리케이션에서 원하는 모양으로 직접 변환: V6

 

권장 순서

1. 엔티티 조회 방식으로 우선 접근

    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로 조회하는 방법도 각각 장단이 있다.

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와 비교해서 성능 차이도 미비하다.