연관관계 고급 & N+1 문제

// Entity 구조
@Entity
public class Order {
    @Id @GeneratedValue
    private Long id;
    
    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "customer_id")
    private Customer customer;
}

// 주문 목록 조회
List<Order> orders = orderRepository.findAll();
// 쿼리 1: SELECT * FROM orders

// 각 주문의 고객 이름 출력
for (Order order : orders) {
    System.out.println(order.getCustomer().getName());
    // 쿼리 2: SELECT * FROM customers WHERE id = 1
    // 쿼리 3: SELECT * FROM customers WHERE id = 2
    // 쿼리 4: SELECT * FROM customers WHERE id = 3
    // ... N개의 추가 쿼리!
}

// 결과: 1(주문 조회) + N(고객 조회) = N+1 쿼리 발생!

-- 1. 주문 목록 조회 (1개 쿼리)
SELECT o.id, o.customer_id, o.order_date, o.status 
FROM orders o;

-- 2. 각 주문의 고객 조회 (N개 쿼리)
SELECT c.id, c.name, c.email FROM customers c WHERE c.id = 1;
SELECT c.id, c.name, c.email FROM customers c WHERE c.id = 2;
SELECT c.id, c.name, c.email FROM customers c WHERE c.id = 3;
SELECT c.id, c.name, c.email FROM customers c WHERE c.id = 4;
SELECT c.id, c.name, c.email FROM customers c WHERE c.id = 5;
-- ... 주문 수만큼 반복!

-- 100개 주문 조회 시: 1 + 100 = 101개 쿼리 실행!

// Repository
public interface OrderRepository extends JpaRepository<Order, Long> {
    
    // Fetch Join으로 Customer 함께 조회
    @Query("SELECT o FROM Order o JOIN FETCH o.customer")
    List<Order> findAllWithCustomer();
    
    // 조건 추가
    @Query("SELECT o FROM Order o JOIN FETCH o.customer WHERE o.status = :status")
    List<Order> findByStatusWithCustomer(@Param("status") OrderStatus status);
}

// 사용
List<Order> orders = orderRepository.findAllWithCustomer();
for (Order order : orders) {
    // 추가 쿼리 없음! 이미 로딩됨
    System.out.println(order.getCustomer().getName());
}

// 실행되는 쿼리 (단 1개!)
// SELECT o.*, c.* 
// FROM orders o 
// INNER JOIN customers c ON o.customer_id = c.id

// Order의 OrderItems 함께 조회
@Query("SELECT o FROM Order o JOIN FETCH o.orderItems")
List<Order> findAllWithOrderItems();

// 여러 연관관계 함께 조회
@Query("SELECT o FROM Order o " +
       "JOIN FETCH o.customer " +
       "JOIN FETCH o.orderItems oi " +
       "JOIN FETCH oi.product")
List<Order> findAllWithCustomerAndItems();

// 실행되는 쿼리
// SELECT o.*, c.*, oi.*, p.*
// FROM orders o
// JOIN customers c ON o.customer_id = c.id
// JOIN order_items oi ON o.id = oi.order_id
// JOIN products p ON oi.product_id = p.id

public interface OrderRepository extends JpaRepository<Order, Long> {
    
    // attributePaths로 함께 조회할 연관관계 지정
    @EntityGraph(attributePaths = {"customer"})
    List<Order> findAll();
    
    // 여러 연관관계 지정
    @EntityGraph(attributePaths = {"customer", "delivery"})
    List<Order> findByStatus(OrderStatus status);
    
    // 중첩 연관관계
    @EntityGraph(attributePaths = {"customer", "orderItems", "orderItems.product"})
    Optional<Order> findById(Long id);
    
    // 메서드 이름 쿼리와 함께 사용
    @EntityGraph(attributePaths = {"customer"})
    List<Order> findByCustomerId(Long customerId);
}

// 사용
List<Order> orders = orderRepository.findAll();
// LEFT OUTER JOIN으로 customer 함께 조회

// Entity에 Named EntityGraph 정의
@Entity
@NamedEntityGraph(
    name = "Order.withCustomer",
    attributeNodes = @NamedAttributeNode("customer")
)
@NamedEntityGraph(
    name = "Order.withAll",
    attributeNodes = {
        @NamedAttributeNode("customer"),
        @NamedAttributeNode("delivery"),
        @NamedAttributeNode(value = "orderItems", subgraph = "orderItems")
    },
    subgraphs = @NamedSubgraph(
        name = "orderItems",
        attributeNodes = @NamedAttributeNode("product")
    )
)
public class Order {
    @Id @GeneratedValue
    private Long id;
    
    @ManyToOne(fetch = FetchType.LAZY)
    private Customer customer;
    
    @OneToOne(fetch = FetchType.LAZY)
    private Delivery delivery;
    
    @OneToMany(mappedBy = "order")
    private List<OrderItem> orderItems = new ArrayList<>();
}

// Repository에서 사용
public interface OrderRepository extends JpaRepository<Order, Long> {
    
    @EntityGraph(value = "Order.withCustomer")
    List<Order> findByStatus(OrderStatus status);
    
    @EntityGraph(value = "Order.withAll")
    Optional<Order> findDetailById(Long id);
}

@Entity
public class Order {
    @Id @GeneratedValue
    private Long id;
    
    // @ManyToOne에 적용
    @ManyToOne(fetch = FetchType.LAZY)
    @BatchSize(size = 100)  // 최대 100개씩 IN 쿼리
    @JoinColumn(name = "customer_id")
    private Customer customer;
    
    // @OneToMany에 적용
    @OneToMany(mappedBy = "order")
    @BatchSize(size = 100)
    private List<OrderItem> orderItems = new ArrayList<>();
}

// 또는 연관 Entity 클래스에 적용
@Entity
@BatchSize(size = 100)  // 이 Entity를 조회할 때 배치 적용
public class Customer {
    @Id @GeneratedValue
    private Long id;
    private String name;
}

// @BatchSize 없이 (N+1 발생)
List<Order> orders = orderRepository.findAll();  // 100개 주문
for (Order order : orders) {
    order.getCustomer().getName();  // 100번의 추가 쿼리!
}
// 총 101개 쿼리

// @BatchSize(size = 100) 적용 시
List<Order> orders = orderRepository.findAll();  // 100개 주문
for (Order order : orders) {
    order.getCustomer().getName();  // IN 쿼리 1번!
}
// 총 2개 쿼리

// 실행되는 쿼리
-- 1. 주문 조회
SELECT * FROM orders;

-- 2. 고객 배치 조회 (IN 쿼리)
SELECT * FROM customers 
WHERE id IN (1, 2, 3, 4, 5, ... 100);

# application.yml
spring:
  jpa:
    properties:
      hibernate:
        default_batch_fetch_size: 100  # 전역 배치 사이즈

# 모든 지연 로딩에 자동 적용
# 개별 @BatchSize로 오버라이드 가능

@Entity
@Table(name = "orders")
public class Order {
    @Id @GeneratedValue
    private Long id;
    
    // Order 저장/삭제 시 OrderItem도 함께
    @OneToMany(mappedBy = "order", cascade = CascadeType.ALL)
    private List<OrderItem> orderItems = new ArrayList<>();
    
    // Order 저장/삭제 시 Delivery도 함께
    @OneToOne(cascade = CascadeType.ALL)
    @JoinColumn(name = "delivery_id")
    private Delivery delivery;
    
    public void addOrderItem(OrderItem item) {
        orderItems.add(item);
        item.setOrder(this);
    }
}

// 사용: Order만 저장하면 OrderItem, Delivery도 함께 저장
Order order = new Order();
order.setDelivery(new Delivery(address));
order.addOrderItem(OrderItem.create(product1, 2));
order.addOrderItem(OrderItem.create(product2, 1));

orderRepository.save(order);  // 3개 Entity 모두 INSERT

// application.yml - 전역 설정
spring:
  jpa:
    properties:
      hibernate:
        default_batch_fetch_size: 100
        
// Order Entity
@Entity
@Table(name = "orders")
public class Order extends BaseEntity {
    @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @ManyToOne(fetch = FetchType.LAZY)  // 항상 LAZY
    @JoinColumn(name = "customer_id")
    private Customer customer;
    
    @OneToMany(mappedBy = "order", cascade = CascadeType.ALL, orphanRemoval = true)
    private List<OrderItem> orderItems = new ArrayList<>();
    
    @OneToOne(fetch = FetchType.LAZY, cascade = CascadeType.ALL)
    @JoinColumn(name = "delivery_id")
    private Delivery delivery;
    
    @Enumerated(EnumType.STRING)
    private OrderStatus status;
}

// OrderRepository - 상황별 조회 메서드
public interface OrderRepository extends JpaRepository<Order, Long> {
    
    // 목록 조회: Customer만 Fetch Join
    @EntityGraph(attributePaths = {"customer"})
    Page<Order> findByStatus(OrderStatus status, Pageable pageable);
    
    // 상세 조회: 모든 연관관계 Fetch Join
    @Query("SELECT o FROM Order o " +
           "JOIN FETCH o.customer " +
           "JOIN FETCH o.delivery " +
           "WHERE o.id = :id")
    Optional<Order> findDetailById(@Param("id") Long id);
    
    // OrderItems는 @BatchSize로 자동 처리
}

@Service
@RequiredArgsConstructor
@Transactional(readOnly = true)
public class OrderService {
    
    private final OrderRepository orderRepository;
    
    // 주문 목록 조회 (페이징)
    public Page<OrderListDto> getOrders(OrderStatus status, Pageable pageable) {
        Page<Order> orders = orderRepository.findByStatus(status, pageable);
        
        // DTO 변환 (OrderItems는 @BatchSize로 IN 쿼리)
        return orders.map(order -> new OrderListDto(
            order.getId(),
            order.getCustomer().getName(),
            order.getStatus(),
            order.getOrderItems().size(),  // @BatchSize 적용
            order.getTotalPrice()
        ));
    }
    
    // 주문 상세 조회
    public OrderDetailDto getOrderDetail(Long orderId) {
        Order order = orderRepository.findDetailById(orderId)
            .orElseThrow(() -> new EntityNotFoundException("주문을 찾을 수 없습니다"));
        
        return new OrderDetailDto(order);
    }
    
    // 주문 생성
    @Transactional
    public Long createOrder(Long customerId, List<OrderItemRequest> items, Address address) {
        Customer customer = customerRepository.findById(customerId).orElseThrow();
        
        Order order = Order.create(customer, new Delivery(address));
        
        for (OrderItemRequest item : items) {
            Product product = productRepository.findById(item.getProductId()).orElseThrow();
            order.addOrderItem(OrderItem.create(product, item.getQuantity()));
        }
        
        orderRepository.save(order);  // Cascade로 OrderItem, Delivery 함께 저장
        return order.getId();
    }
}

// Command Service (쓰기)
@Service
@RequiredArgsConstructor
@Transactional
public class OrderService {
    public Long order(Long memberId, Long productId, int count) {
        // 비즈니스 로직
    }
}

// Query Service (읽기) - OSIV OFF에서 필수
@Service
@RequiredArgsConstructor
@Transactional(readOnly = true)
public class OrderQueryService {
    
    public OrderDto findOrder(Long orderId) {
        // 트랜잭션 안에서 DTO 변환 완료
        Order order = orderRepository.findByIdWithMemberDelivery(orderId)
            .orElseThrow();
        return OrderDto.from(order);
    }
}

// Controller
@RestController
@RequiredArgsConstructor
public class OrderController {
    
    private final OrderQueryService orderQueryService;
    
    @GetMapping("/api/orders/{id}")
    public OrderDto getOrder(@PathVariable Long id) {
        return orderQueryService.findOrder(id); // 이미 DTO
    }
}

// COUNT 쿼리 분리 (복잡한 조인이 있는 경우)
@Query(value = "select m from Member m left join m.team t",
       countQuery = "select count(m) from Member m") // 조인 없이 카운트
Page<Member> findByAge(int age, Pageable pageable);

// No Offset 페이징 (커서 기반) - 대용량 데이터에 효과적
@Query("select m from Member m where m.id > :lastId order by m.id")
List<Member> findByIdGreaterThan(@Param("lastId") Long lastId, Pageable pageable);

spring:
  datasource:
    hikari:
      maximum-pool-size: 10
      minimum-idle: 5
      connection-timeout: 30000
      
  jpa:
    hibernate:
      ddl-auto: validate  # 운영: validate, 개발: update
    properties:
      hibernate:
        format_sql: true
        default_batch_fetch_size: 100  # N+1 방어
        jdbc:
          batch_size: 50
        order_inserts: true
        order_updates: true
    open-in-view: false  # 실시간 서비스 권장
    
logging:
  level:
    org.hibernate.SQL: DEBUG  # 개발 환경만

// ❌ 문제 발생
@Service
public class MemberService {
    @Transactional
    public Member findMember(Long id) {
        return memberRepository.findById(id).get();
    }
}

@RestController
public class MemberController {
    @GetMapping("/members/{id}")
    public MemberDto getMember(@PathVariable Long id) {
        Member member = memberService.findMember(id);
        // 트랜잭션 종료 후 접근 → LazyInitializationException!
        return new MemberDto(member.getName(), member.getTeam().getName());
    }
}

// ✅ 해결책 1: 트랜잭션 안에서 DTO 변환
@Service
@Transactional(readOnly = true)
public class MemberService {
    public MemberDto findMemberDto(Long id) {
        Member member = memberRepository.findById(id).get();
        return new MemberDto(member.getName(), member.getTeam().getName());
    }
}

// ✅ 해결책 2: Fetch Join 사용
@Query("select m from Member m join fetch m.team where m.id = :id")
Optional<Member> findByIdWithTeam(@Param("id") Long id);

// ✅ 해결책 3: EntityGraph 사용
@EntityGraph(attributePaths = {"team"})
Optional<Member> findById(Long id);

// 낙관적 락
@Entity
public class Product {
    @Version
    private Long version;
}

// 비관적 락
@Lock(LockModeType.PESSIMISTIC_WRITE)
@Query("select p from Product p where p.id = :id")
Optional<Product> findByIdWithPessimisticLock(@Param("id") Long id);