엔티티 매핑 분석

위의 다이어그램을 코드로 짜본다.

jpa 엔티티 매핑을 생각하며, 짜본다.

 

1. Member

1. id

@Id, @GeneratedValue, @Column(name = "member_id") 

2. name

3. address

embedded 타입의 Address 엔티티.

-> @Embedable

4. orders

Member엔티티와 Order엔티티는 양방향 일대다 관계이다.

-양방향: 연관관계의 주인

-연관관계의 주인은 보통 일보단 다쪽이다.

-즉, mappedBy를 통해 Order쪽에 자신의 pk가 있음을 선언한다. --> @OneToMany(mappedBy = "member") = Order엔티티의 member컬럼(필드)에 자신의 pk가 있다.

package jpabook.jpabook.domain;

import jakarta.persistence.*;
import lombok.Getter;
import lombok.Setter;

import java.util.ArrayList;
import java.util.List;

@Entity
@Getter @Setter
public class Member {
    @Id
    @GeneratedValue
    @Column(name = "memeber_id")
    private Long id;

    private String name;

    @Embedded
    private Address address;

    @OneToMany(mappedBy = "member")
    private List<Order> orders = new ArrayList<>();


}

 

2. Order

1. id

@Id, @GeneratedValue, @Column(name = "order_id")

2. member

Member와 Order는 양방향 일대다 관계이다.

양방향이므로 연관관계의 주인을 고려해야 한다.

Order엔티티가 다쪽이므로 연관관계의 주인이다.

@ManyToOne, @JoinColumn(name = "member_id") -> 컬럼명을 써준다.

 3.orderitems

Order엔티티와 Item엔티티는 다대다 관계이다. 일반적으로 다대다 관계는 중간에 매개 테이블을 만들어서 사용한다.

-ORDER_ITEM이라는 테이블을 만들어 사용한다.

Order엔티티와 Order_Item엔티티는 양방향 일대다 관계이다.

즉, 연관관계의 주인은 order이 아니다.

OrderItem의 order(fk)컬럼을 통해 연관관계 성립되기 때문에

그러므로, @OneToMany(mappedBy = "order")을 사용한다.

4. delivery

delivery와 order은 양방향 일대일 관계이다.

양방향=연관관계 주인

일대일이므로, 어디에나 연관관계의 주인을 써주어도 괜찮지만, order에 써주기로 한다.

@OneToOne, @JoinColumn(name = "order_id")

5.orderdate

6.status

status는 enum타입을 저장하는 컬럼(필드)이다.

@Enumerated(EnumType.STRING)를 사용한다.

 

package jpabook.jpabook.domain;

import jakarta.persistence.*;
import lombok.Getter;
import lombok.Setter;

import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.List;

@Entity
@Table(name = "orders")
@Getter @Setter
public class Order {

    @Id
    @GeneratedValue
    @Column(name = "order_id")
    private Long id;

    @ManyToOne
    @JoinColumn(name = "member_id")
    private Member member;

    @OneToMany(mappedBy = "order")
    private List<OrderItems> orderItems = new ArrayList<>();

    @OneToOne
    @JoinColumn(name = "delivery_id")
    private Delivery delivery;

    private LocalDateTime orderDate;

    @Enumerated(EnumType.STRING)
    private OrderStatus status;
}

 

3. delivery

1. id

@Id, @Column(name = "delivery_id"), @GeneratedValue

2. order

양방향 일대일 관계, 주인은 Orders이다.

@OneToOne(mappedBy = "delivery")

3. Adress

@Embedable

4. status

@Enumerated

package jpabook.jpabook.domain;

import jakarta.persistence.*;
import lombok.Getter;
import lombok.Setter;
import org.springframework.context.annotation.EnableMBeanExport;

@Entity
@Getter @Setter
public class Delivery {
    @Id
    @GeneratedValue
    @Column(name = "delivery_id")
    private Long id;

    @OneToOne(mappedBy = "delivery")
    private Order order;

    @Embedded
    private Address address;

    @Enumerated(EnumType.STRING)
    private DeliveryStatus status;
}

4. OrderItem

orderitem은 다대다 관계인 Order과 Item을 위한 테이블이다.

1. id

@Id, @Column(name = "orderitem_id"), @GeneratedValue

2. item

OrderItem과 Item은 단방향 일대다 관계이다.

즉, mappedBy 없이 @JoinColumn(name = "itme_id")

3. order

Order과 OrderItem은 일대다 양방향 관계이다.

다쪽은 orderitem이기 때문에, 연관관계의 주인은 orderitem이다.

@ManyToOne, @JoinColumn(name = "order_id")

4.orderprice

5.count

package jpabook.jpabook.domain;

import jakarta.persistence.*;
import jpabook.jpabook.domain.item.Item;
import lombok.Getter;
import lombok.Setter;

@Entity
@Getter @Setter
public class OrderItems {
    @Id
    @GeneratedValue
    @Column(name = "order_Item_id")
    private Long id;

    @ManyToOne
    @JoinColumn(name = "item_id")
    private Item item;

    @ManyToOne
    @JoinColumn(name = "order_id")
    private Order order;

    private int orderPrice;
    private int count;
}

 

5. Item

1. id

@Id, @Column(name = "item_id"), @GeneratedValue

2. name

3. price

4. stockquantity

5. category

양방향 다대다 관계 원래라면, 중간에 연결 엔티티를 만들어 일대다 다대일 관계로 매핑해야하지, 여기서는 다양한 관계를 보여주고자, 바로 매핑해주었다.(이렇게 매핑하는 것은 몰라도 될 듯??)

package jpabook.jpabook.domain.item;

import jakarta.persistence.*;
import jpabook.jpabook.domain.Category;
import lombok.Getter;
import lombok.Setter;

import java.util.ArrayList;
import java.util.List;

@Entity
@Inheritance(strategy = InheritanceType.SINGLE_TABLE)
@DiscriminatorColumn(name = "dtype")
@Getter@Setter
public abstract class Item {
    @Id
    @GeneratedValue
    @Column(name = "item_id")
    private Long id;

    private String name;

    private int price;

    private int StockQuantity;

    @ManyToMany(mappedBy = "items")
    private List<Category> categories = new ArrayList<>();
}

 

위의 코드를 보면 @Inheritance와 @DiscriminatorColumn이 있다. 

 

<이 글은 김영한님의 강의를 듣고 작성되었습니다.>