API 개발 ‐ 주문 조회 API 개발시 주의사항(일대다) - dnwls16071/Backend_Study_TIL GitHub Wiki

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

                // Member 엔티티(지연로딩 설정) 강제 초기화
		order.getMember().getName();
		
                // Delivery 엔티티(지연로딩 설정) 강제 초기화
                order.getDelivery().getAddress();
		List<OrderItem> orderItems = order.getOrderItems();

		for (OrderItem orderItem : orderItems) {

                        // Item 엔티티(지연로딩 설정) 강제 초기화
			orderItem.getItem().getName();
		}
	}
	return all;
}

// 프록시 초기화를 위한 스프링 빈을 등록
@Bean
public Hibernate5JakartaModule hibernate5Module() {
	return new Hibernate5JakartaModule();
}

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

@Data
static class OrderDto {

	private Long orderId;
	private String name;
	private LocalDateTime orderDate;
	private OrderStatus orderStatus;
	private Address address;
	// private List<OrderItem> orderItems;(엔티티 X, DTO O)
	private List<OrderItemDto> orderItems;

	public OrderDto(Order order) {
		this.orderId = order.getId();
		this.name = order.getMember().getName();
		this.orderDate = order.getOrderDate();
		this.orderStatus = order.getStatus();
		this.address = order.getDelivery().getAddress();
		this.orderItems = order.getOrderItems().stream()
				.map(OrderItemDto::new)
				.collect(Collectors.toList());
	}
}

@Data
static class OrderItemDto {

	private String itemName;
	private int orderPrice;
	private int count;

	public OrderItemDto(OrderItem orderItem) {
		this.itemName = orderItem.getItem().getName();
		this.orderPrice = orderItem.getOrderPrice();
		this.count = orderItem.getCount();
	}
}

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

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

@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> all = orderRepository.findAllWithMemberDelivery(offset, limit);
	List<OrderDto> list = all.stream().map(OrderDto::new).toList();
	return list;
}	

public List<OrderQueryDto> findOrderItemQueryDtos() {
    
    // 쿼리 1번 OrderQueryDto 호출
    List<OrderQueryDto> result = findOrders();

    // for문 루프 반복을 통한 쿼리 N번 호출
    result.forEach(orderQueryDto -> {
	List<OrderItemQueryDto> orderItems = findOrderItems(orderQueryDto.getOrderId());
	orderQueryDto.setOrderItems(orderItems);
    });
    return result;
}

// 1 : N 관계 조회
private List<OrderItemQueryDto> findOrderItems(Long orderId) {
	return em.createQuery(
		"select new com.example.younghanapi2.api.dto.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();
}

// DTO의 경우 페치 조인 적용 불가(엔티티가 아닌 데이터 전송용 객체이기 때문에)
// 1 : N 관계(여기선, 주문과 주문상품)를 제외한 나머지 한 번에 조회
public List<OrderQueryDto> findOrders() {
	return em.createQuery("select new com.example.younghanapi2.api.dto.OrderQueryDto(o.id, o.member.name, o.orderDate, o.status, o.delivery.address) from Order o" +
		" join o.member m" +
	        " join o.delivery d", OrderQueryDto.class)
	.getResultList();
}

public List<OrderQueryDto> findAllByDto_optimization() {
	List<OrderQueryDto> orders = findOrders();
	List<Long> orderIds = orders.stream().map(OrderQueryDto::getOrderId).toList();	// orderId 리스트를 스트림을 사용해서 뽑아내기

	List<OrderItemQueryDto> orderItems = em.createQuery(
		"select new com.example.younghanapi2.api.dto.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)    // IN 절을 사용하여 한 번에 조회(N + 1 문제 개선)
	.setParameter("orderIds", orderIds)
	.getResultList();

	orders.forEach(orderQueryDto -> orderQueryDto.setOrderItems(orderItems));
	return orders;
}

@Data
public class OrderFlatDto {

	private Long orderId;
	private String name;
	private LocalDateTime orderDate;
	private OrderStatus orderStatus;
	private Address address;

	// OrderItem 컬렉션을 다 풀어헤친다.
	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;
	}
}

public List<OrderFlatDto> findAllByDto_flat() {
	return em.createQuery(
		"select new com.example.younghanapi2.api.dto.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();
}