연관관계 매핑 기초

// 외래키를 그대로 필드로 가지는 경우
@Entity
public class Order {
    @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    private Long customerId;  // 외래키 직접 보관 (객체지향적이지 않음)
    private Long productId;
}

// 사용 시 불편함
Order order = orderRepository.findById(orderId).orElseThrow();
Long customerId = order.getCustomerId();
Customer customer = customerRepository.findById(customerId).orElseThrow();  // 추가 조회 필요

// 객체 그래프 탐색 불가
// order.getCustomer().getName()  ← 불가능!

// 객체 참조로 연관관계 설정
@Entity
public class Order {
    @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "customer_id")
    private Customer customer;  // 객체 참조!
}

// 사용 시 편리함
Order order = orderRepository.findById(orderId).orElseThrow();
Customer customer = order.getCustomer();  // 바로 접근 가능!
String customerName = order.getCustomer().getName();  // 객체 그래프 탐색

@Entity
@Table(name = "orders")
public class Order {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    // 다대일 단방향
    @ManyToOne(fetch = FetchType.LAZY)  // 지연 로딩 권장
    @JoinColumn(name = "customer_id")   // FK 컬럼명
    private Customer customer;
    
    private LocalDateTime orderDate;
    private BigDecimal totalAmount;
    
    // 연관관계 편의 메서드
    public void setCustomer(Customer customer) {
        this.customer = customer;
    }
}

@Entity
public class Customer {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    private String name;
    private String email;
    
    // Customer에서는 Order를 참조하지 않음 (단방향)
}

// 저장
Customer customer = customerRepository.findById(customerId).orElseThrow();

Order order = new Order();
order.setCustomer(customer);  // 연관관계 설정
order.setOrderDate(LocalDateTime.now());
order.setTotalAmount(new BigDecimal("50000"));

orderRepository.save(order);
// INSERT INTO orders (customer_id, order_date, total_amount) VALUES (?, ?, ?)

// 조회
Order order = orderRepository.findById(orderId).orElseThrow();
Customer customer = order.getCustomer();  // 객체 그래프 탐색
System.out.println(customer.getName());   // 지연 로딩 시 이 시점에 SELECT

@Entity
@Table(name = "orders")
public class Order {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "customer_id")
    private Customer customer;
    
    // 일대일 단방향
    @OneToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "delivery_id")
    private Delivery delivery;
}

@Entity
public class Delivery {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @Embedded
    private Address address;
    
    @Enumerated(EnumType.STRING)
    private DeliveryStatus status;
}

// Order: 연관관계의 주인 (외래키 보유)
@Entity
@Table(name = "orders")
public class Order {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    // 주인: 외래키 관리
    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "customer_id")
    private Customer customer;
    
    // 연관관계 편의 메서드
    public void setCustomer(Customer customer) {
        this.customer = customer;
        customer.getOrders().add(this);  // 양방향 동기화
    }
}

// Customer: 주인이 아님 (mappedBy)
@Entity
public class Customer {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    private String name;
    
    // 주인이 아님: mappedBy로 읽기 전용
    // "order의 customer 필드에 의해 매핑됨"
    @OneToMany(mappedBy = "customer")
    private List<Order> orders = new ArrayList<>();
    
    // 연관관계 편의 메서드
    public void addOrder(Order order) {
        orders.add(order);
        order.setCustomer(this);
    }
}

@Entity
public class Order {
    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "customer_id")
    private Customer customer;
    
    // 연관관계 편의 메서드 (주인 쪽에 작성)
    public void changeCustomer(Customer customer) {
        // 기존 관계 제거
        if (this.customer != null) {
            this.customer.getOrders().remove(this);
        }
        // 새 관계 설정
        this.customer = customer;
        if (customer != null) {
            customer.getOrders().add(this);
        }
    }
}

// 사용
Order order = new Order();
order.changeCustomer(customer);  // 양쪽 모두 자동 설정

// 주문 생성
@Transactional
public Long createOrder(Long customerId, List<OrderItemRequest> items) {
    Customer customer = customerRepository.findById(customerId).orElseThrow();
    
    Order order = new Order();
    order.setCustomer(customer);
    order.setOrderDate(LocalDateTime.now());
    order.setStatus(OrderStatus.PENDING);
    
    for (OrderItemRequest item : items) {
        Product product = productRepository.findById(item.getProductId()).orElseThrow();
        OrderItem orderItem = OrderItem.createOrderItem(product, item.getQuantity());
        order.addOrderItem(orderItem);  // 연관관계 편의 메서드
    }
    
    orderRepository.save(order);  // cascade로 OrderItem도 함께 저장
    return order.getId();
}

@Entity
public class Customer {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    private String email;
    private String name;
    
    // 상세 정보는 필요할 때만 로딩
    @OneToOne(fetch = FetchType.LAZY, cascade = CascadeType.ALL)
    @JoinColumn(name = "customer_detail_id")
    private CustomerDetail detail;
}

@Entity
public class CustomerDetail {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @OneToOne(mappedBy = "detail")
    private Customer customer;
    
    private LocalDate birthDate;
    private String phoneNumber;
    
    @Embedded
    private Address address;
    
    @Lob
    private String memo;
    
    private Integer point = 0;
    private String grade = "BRONZE";
}

// @ManyToMany 사용 (비권장)
@Entity
public class Product {
    @Id @GeneratedValue
    private Long id;
    
    @ManyToMany
    @JoinTable(
        name = "product_category",
        joinColumns = @JoinColumn(name = "product_id"),
        inverseJoinColumns = @JoinColumn(name = "category_id")
    )
    private List<Category> categories = new ArrayList<>();
}

@Entity
public class Category {
    @Id @GeneratedValue
    private Long id;
    
    @ManyToMany(mappedBy = "categories")
    private List<Product> products = new ArrayList<>();
}

// 문제점:
// 1. 중간 테이블(product_category)에 추가 컬럼 불가
//    - 등록일, 순서, 메인 카테고리 여부 등 저장 불가
// 2. 중간 테이블이 숨겨져 있어 예상치 못한 쿼리 발생
// 3. 비즈니스 요구사항 변경에 대응 어려움

// 중간 Entity: ProductCategory
@Entity
@Table(name = "product_category")
public class ProductCategory {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "product_id")
    private Product product;
    
    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "category_id")
    private Category category;
    
    // 추가 컬럼 가능!
    private Integer displayOrder;      // 표시 순서
    private Boolean isMainCategory;    // 메인 카테고리 여부
    private LocalDateTime createdAt;   // 등록일
    
    // 생성 메서드
    public static ProductCategory create(Product product, Category category, 
                                          int order, boolean isMain) {
        ProductCategory pc = new ProductCategory();
        pc.product = product;
        pc.category = category;
        pc.displayOrder = order;
        pc.isMainCategory = isMain;
        pc.createdAt = LocalDateTime.now();
        return pc;
    }
}

@Entity
public class Product {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    private String name;
    
    @OneToMany(mappedBy = "product", cascade = CascadeType.ALL, orphanRemoval = true)
    private List<ProductCategory> productCategories = new ArrayList<>();
    
    // 카테고리 추가
    public void addCategory(Category category, int order, boolean isMain) {
        ProductCategory pc = ProductCategory.create(this, category, order, isMain);
        productCategories.add(pc);
    }
    
    // 메인 카테고리 조회
    public Category getMainCategory() {
        return productCategories.stream()
            .filter(ProductCategory::getIsMainCategory)
            .findFirst()
            .map(ProductCategory::getCategory)
            .orElse(null);
    }
}

@Entity
public class Category {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    private String name;
    
    @OneToMany(mappedBy = "category")
    private List<ProductCategory> productCategories = new ArrayList<>();
    
    // 해당 카테고리의 상품 수
    public int getProductCount() {
        return productCategories.size();
    }
}

// Customer
@Entity
public class Customer extends BaseEntity {
    @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    private String email;
    private String name;
    
    @OneToOne(fetch = FetchType.LAZY, cascade = CascadeType.ALL)
    @JoinColumn(name = "customer_detail_id")
    private CustomerDetail detail;
    
    @OneToMany(mappedBy = "customer")
    private List<Order> orders = new ArrayList<>();
}

// Order
@Entity
@Table(name = "orders")
public class Order extends BaseEntity {
    @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @ManyToOne(fetch = FetchType.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;
    
    private LocalDateTime orderDate;
}

// OrderItem
@Entity
public class OrderItem {
    @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "order_id")
    private Order order;
    
    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "product_id")
    private Product product;
    
    private Integer quantity;
    private BigDecimal orderPrice;
}

// Product
@Entity
public class Product extends BaseEntity {
    @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    private String name;
    private BigDecimal price;
    private Integer stockQuantity;
    
    @OneToMany(mappedBy = "product", cascade = CascadeType.ALL)
    private List<ProductCategory> productCategories = new ArrayList<>();
}

// Category
@Entity
public class Category {
    @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    private String name;
    
    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "parent_id")
    private Category parent;
    
    @OneToMany(mappedBy = "parent")
    private List<Category> children = new ArrayList<>();
    
    @OneToMany(mappedBy = "category")
    private List<ProductCategory> productCategories = new ArrayList<>();
}