[JPA API] 주문, 배송정보, 회원 조회 API

목표

• 주문, 배송정보, 회원을 조회하는 API 만들기 
• 지연 로딩 때문에 발생하는 성능 문제를 단계적으로 해결해보기(중요)

---

샘플 데이터 입력 

package jpabook.jpashop;

import jpabook.jpashop.domain.*;
import jpabook.jpashop.domain.item.Book;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.PostConstruct;
import javax.persistence.EntityManager;

/**
 * 종 주문 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();
    }

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

---

간단한 주문 조회: 엔티티를 DTO로 변환

• 엔티티를 DTO로 변환하는 일반적인 방법
• 쿼리가 총 1 + N + N번 실행됨
  • order 조회 1번 
  • order -> member 지연 로딩 조회 N번
  • order -> delevery 지연 로딩 조회 N번 
• 성능 문제가 있음

V2

@GetMapping("/api/v2/simple-orders")
public List<SimpleOrderDto> orderV2(){
	// ORDER 2개가 조회
    // N + 1 -> 1 + 회원N + 배송N
    List<Order> orders = orderRepository.findAllByString(new OrderSearch());
    
    List<SimpleOrderDto> reulst = orders.stream()
            .map(o -> new SimpleOrderDto(o))
            .collect(Collectors.toList());
    return reulst;
}

@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(); // LAZY 초기화, 쿼리 날림 
        orderDate = order.getOrderDate();
        orderStatus = order.getStatus();
        address = order.getDelivery().getAddress(); // LAZY 초기화, 쿼리 날림 
    }
}

---

간단한 주문 조회: 엔티티를 DTO로 변환 - 페치 조인 최적화

• 엔티티를 페치 조인(fetch join)을 사용해서 쿼리 1번에 조회 
• 페치 조인으로 order -> member, order-> delivery 는 이미 조회 된 상태 이므로 지연로딩X
• V4보다 재사용성이 좋음

Order Entity

// Order Entity의 member와 delivery
@ManyToOne(fetch = LAZY) 
@JoinColumn(name = "member_id")
private Member member; // 양방향

@JsonIgnore
@OneToOne(fetch = LAZY, cascade = CascadeType.ALL)
@JoinColumn(name = "delivery_id")
private Delivery delivery; // 단방향

Order Repository 

• fetch 조인을 사용 

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

V3

@GetMapping("/api/v3/simple-orders")
public List<SimpleOrderDto> orderV3(){
    List<Order> orders = orderRepository.findAllWithMemberDelivery();
    List<SimpleOrderDto> result = orders.stream()
            .map(o -> new SimpleOrderDto(o))
            .collect(Collectors.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();
    }
}

DB에 날린 쿼리 

• V2는 for문을 돌 때 쿼리가 추가로 DB에 날렸는데, V3에서는 join fetch를 통해 쿼리가 1개만 나간 것을 볼 수 있음.

결과

---

간단한 주문 조회: JPA에서 DTO로 바로 조회

• 재사용성이 낮다는 단점이 있음. 
• 성능 최적화가 V3보다 좀 더 좋음 
• API 스펙이 바뀌면 repository를 고쳐야 한다는 단점도 존재.
  • 패키지를 하나 더 만들어서 Dto랑 Query만 따로 뽑아서 사용하는 것도 방법 중 하나
  • 예) repository/order/query 안에다가 Dto와 쿼리를 따로 저장. 

V4

@GetMapping("/api/v4/simple-orders")
public List<OrderSimpleQueryDto> orderV4(){
    return orderRepository.findOrderDtos();

}

OrderSimpleQueryDto

package jpabook.jpashop.repository;

import jpabook.jpashop.domain.Address;
import jpabook.jpashop.domain.OrderStatus;
import lombok.Data;

import java.time.LocalDateTime;

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

OrderRepository

public List<OrderSimpleQueryDto> findOrderDtos() {
    return em.createQuery(
    			// new 경로.Dto 꼭 적어주어야함
            "select new jpabook.jpashop.repository.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();
}

쿼리

• 필요한 데이터만 뽑아서 Dto로 변환(V3는 모든 데이터를 가져옴)

---

정리

• 엔티티를 DTO로 변환하거나, DTO로 바로 조회하는 두가지ㅣ 방법은 각각 장단점이 있다. 둘중 상황에 따라서 더나은 방법을 선택하면 됨. 엔티티를 조회하면 리포지토리 재사용성도 좋고 개발도 단순. 따라서 권장하는 방법은 다음과 같음 
  1. 우선 엔티티를 DTO로 변환하는 방법을 선택
  2. 필요하면 페치 조인으로 성능을 최적화 -> 대부분의 성능 이슈가 해결
  3. 그래도 안되면 DTO로 직접 조회화는 방법을 사용
  4. 최후의 방법은 JPA가 제공하는 네이티브 SQL이나 스프링 JDBC Template을 사용해서 SQL을 직접 사용