다양한 연관관계 매핑

※ 연관관계 매핑시 고려사항 3가지

 

- 다중성

- 단방향, 양방향

- 연관관계의 주인

 

 

※ 다중성

 

- 다대일 : @ManyToOne

- 일대다 : @OneToMany

- 일대일 : @OneToOne

- 다대다 : @ManyToMany (다대다는 실무에서 사용하지 않음)

 

 

※ 단방향, 양방향

 

테이블

- 외래키 하나로 양쪽 조인이 가능하다.

- 사실 방향이라는 개념이 없다.

 

객체

- 참조용 필드가 있는 쪽으로만 참조가 가능하다.

- 한쪽만 참조하면 단방향이다.

- 양쪽이 서로 참조하면 양방향이다.

 

 

※ 연관관계의 주인

 

테이블은 외래키 하나로 두 테이블이 연관관계를 맺는다.

객체 양방향 관계는 A ~> B, B ~> A 처럼 참조가 2군데 있다. (둘중 테이블의 외래키를 관리할 곳 지정)

연관관계의 주인은 외래키를 관리하는 곳이 되며, 주인의 반대편은 외래키에 영향을 주지 않고 단순 조회만 가능하다.

 

 

다대일 [N:1]

 

※ 다대일 단방향

 

 

가장 많이 사용하는 연관관계로 다대일의 반대는 일대다 이다.

 

 

※ 다대일 양방향

 

 

외래키가 있는 쪽이 연관관계의 주인이다.

양쪽을 서로 참조하도록 개발해야 한다.

 

 

일대다 [1:N]

 

※ 일대다 단방향

 

 

위 구조를 클래스로 작성하면 다음과 같다.

@Entity
public class Member {

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

    @Column(name = "USERNAME")
    private String username;
    ...
}

@Entity
public class Team {

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

    @OneToMany
    @JoinColumn(name = "TEAM_ID")
    private List<Member> members = new ArrayList<>();
    ...
}

 

위와 같이 클래스를 생성하였고 팀에 특정 멤버가  속하도록 하는 코드를 작성하면 다음과 같다.

EntityManagerFactory emf = Persistence.createEntityManagerFactory("hello");
EntityManager em = emf.createEntityManager();
EntityTransaction tx = em.getTransaction();

tx.begin();

try {
    Member member = new Member();
    member.setUsername("member1");

    em.persist(member);

    Team team = new Team();
    team.setName("teamA");
    team.getMembers().add(member);

    em.persist(team);

    tx.commit();
} catch(Exception e) {
    tx.rollback();
} finally {
    em.close();
}

emf.close();

 

정상적으로 데이터 삽입이 잘 된 모습이다.

그런데 데이터 삽입만 했을 뿐인데 update 쿼리가 뜬금없이 나타난 모습이다.

"team.getMembers().add(member);" 를 수행할 때 생기는 문제인데, 이전에 member 를 삽입만 했을 때

아래와 같이 TEAM_ID 에 대한 칼럼값이 NULL 인 상태이다.

 

 

따라서 팀에 멤버를 추가하면서 팀은 멤버의 TEAM_ID 를 join 하기 때문에 자연스럽게 update 쿼리가

생성된 것으로 이해할 수 있다.

일대다 관계는 실무에서 잘 안쓰인다고 하는데 그 이유는 위와 같이 저장만 했을 뿐인데 뜬금없이

update 쿼리가 나타나면서 디버깅이 힘들어지는 문제가 존재하기 때문이다.

위와 같은 문제를 해결하기 위해 다대일 단방향을 양방향으로 수정하여 좀 더 유연하게 대처할 수 있다.

 

 

※ 일대다 단방향 정리

 

일대다 단방향은 일대다(1:N) 에서 일(1)이 연관관계의 주인이다.

테이블 일대다 관계는 항상 다(N) 쪽에 외래키가 있다.

객체와 테이블 차이 때문에 반대편 테이블의 외래키를 관리하는 특이한 구조이다.

@JoinColumn 을 꼭 사용해야 하며 그렇지 않을 경우 조인 테이블 방식을 사용한다. (중간에 테이블 하나 추가)

 

일대다 단방향 매핑의 단점

- 엔티티가 관리하는 외래키가 다른 테이블에 있다는 점이다.

- 연관관계 관리를 위해 추가로 UPDATE SQL 을 실행한다.

 

일대다 단방향 매핑보다는 다대일 양방향 매핑을 사용하자.

 

 

일대일 관계

 

일대일 관계는 그 반대도 일대일이다.

주 테이블이나 대상 테이블 중에 외래키 선택이 가능하다.

- 주 테이블에 외래키

- 대상 테이블에 외래키

외래키에 데이터베이스 유니크(UNI) 제약조건을 추가해야 한다.

 

 

※ 일대일 : 주 테이블에 외래키 단방향

 

 

다대일(@ManyToOne) 단방향 매핑과 유사하다.

 

 

※ 일대일 : 주 테이블에 외래키 양방항

 

 

다대일 양방향 매핑처럼 외래키가 있는 곳이 연관관계의 주인이다.

반대편은 mappedBy 를 적용하면 된다.

 

위와 같은 구조를 클래스화 하면 다음과 같다.

@Entity
public class Member {

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

    @Column(name = "USERNAME")
    private String username;

    @OneToOne
    @JoinColumn(name = "LOCKER_ID")
    private Locker locker;
    ...
}

@Entity
public class Locker {

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

    private String name;

    @OneToOne(mappedBy = "locker")
    private Member member;
}

 

 

※ 일대일 정리

 

주 테이블에 외래키

- 주 객체가 대상 객체의 참조를 가지는 것처럼 주 테이블에 외래키를 두고 대상 테이블을 찾는다.

- 객체지향 개발자가 선호하며 JPA 매핑이 편리하다.

- 장점 : 주 테이블만 조회해도 대상 테이블에 데이터가 있는지 확인이 가능하다.

- 단점 : 값이 없으면 외래키에 null 이 허용된다.

 

대상 테이블에 외래키

- 대상 테이블에 외래키가 존재한다.

- 전통적인 데이터베이스 개발자가 선호하는 방식이다.

- 장점 : 주 테이블과 대상 테이블을 일대일에서 일대다 관계로 변경할 때 테이블 구조를 유지한다.

- 단점 : 프록시 기능의 한계로 지연 로딩으로 설정해도 항상 즉시 로딩된다. 

 

 

다대다 [N:M]

 

관계형 데이터베이스는 정규화된 테이블 2개로 다대다 관계를 표현할 수 없다.

연결 테이블을 추가해서 일대다, 다대일 관계로 풀어내야 한다.

 

 

객체는 컬렉션을 사용해서 객체 2개로 다대다 관계가 가능하다.

 

 

@ManyToMany 를 사용하고 @JoinTable 로 연결 테이블을 지정한다.

다대다 매핑은 단방향, 양방향이 가능하다.

 

위 구조를 클래스화 하면 다음과 같다.

@Entity
public class Member {

    @ManyToMany
    @JoinTable(name = "MEMBER_PRODUCT")
    private List<Product> products = new ArrayList<>();
    
    ...
}

@Entity
public class Product {

    @Id @GeneratedValue
    private Long id;

    private String name;
    
    ...
}

 

정상적으로 member, product 테이블 사이에 member_product 테이블이 생성된 것을 확인할 수 있다.

member_product 테이블에는 member, product 에 대한 외래키가 담겨져 있으며 이로 인해

다대다 관계를 일대다, 다대일 관계로 변경되었다.

 

만약에 양방향으로 Product 에서 여러 member 를 확인하고 싶을 경우?

아래와 같이 코드를 추가해주면 된다.

@Entity
public class Product {

    @ManyToMany(mappedBy = "products")
    private List<Member> members = new ArrayList<>();
	
    ...
}

 

Member 에서 @joinTable 을 통해 두 테이블 사이에 연결 테이블을 생성했으므로,

Product 에서는 일대다 관계처럼 mappedBy 를 해주면 된다.

 

 

※ 다대다 매핑의 한계

 

편리해 보이지만 실무에서 사용되지 않는다.

연결 테이블이 단순히 연결만 하고 끝나지 않는다.

주문시간, 수량 같은 데이터를 추가하고 싶어도 추가할 수가 없다.

(member_id, product_id 외래키만 존재)

 

 

※ 다대다 한계 극복

 

연결 테이블용 엔티티를 추가한다. (연결 테이블을 엔티티로 승격)

@ManyToMany 를 @OneToMany, @ManyToOne 으로 해결할 수 있다.

 

 

위 구조를 클래스화 하면 다음과 같다.

@Entity
public class MemberProduct {

    @Id @GeneratedValue
    private Long id;

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

    @ManyToOne
    @JoinColumn(name = "PRODUCT_ID")
    private Product product;
}

 

우선 MemberProduct 에 대한 엔티티를 위와 같이 생성한다.

@Entity
public class Member {

    @OneToMany(mappedBy = "member")
    private List<MemberProduct> memberProducts = new ArrayList<>();
    
    ...
}

@Entity
public class Product {

    @OneToMany(mappedBy = "product")
    private List<MemberProduct> memberProduct = new ArrayList<>();
    
    ...
}

 

그 다음에 @ManyToMany 를 @OneToMany 로 변경시켜서 매핑정보만 추가해주면 된다.

그러면 아래와 같이 생성되는 것을 확인할 수 있다.

 

 

 

실전 예제 3 - 다양한 연관관계 매핑

 

주문과 배송은 1:1(@OneToOne) 이다.

상품과 카테고리는 N:M(@ManyToMany) 이다.

 

 

배송, 카테고리를 추가한 ERD, 엔티티는 아래와 같다.

 

 

Member 클래스

@Entity
public class Member {

    @Id @GeneratedValue
    @Column(name = "MEMBER_ID")
    private Long id;
    private String name;
    private String city;
    private String street;
    private String zipcode;

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

 

Order 클래스

@Entity
@Table(name = "ORDERS")
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<OrderItem> orderItems = new ArrayList<>();

    private LocalDateTime orderDate;

    @Enumerated(EnumType.STRING)
    private OrderStatus status;

    @OneToOne
    @JoinColumn(name = "DELIVERY_ID")
    private Delivery delivery;
    
    ...
}

 

Delivery 클래스

@Entity
public class Delivery {

    @Id @GeneratedValue
    private Long id;

    private String city;
    private String street;
    private String zipcode;
    private DeliveryStatus status;

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

 

OrderItem 클래스

@Entity
public class OrderItem {

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

 

Item 클래스

@Entity
public 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<>();
    
    ...
}

 

Category 클래스

@Entity
public class Category {

    @Id
    @GeneratedValue
    private Long id;

    private String name;

    @ManyToOne
    @JoinColumn(name = "PARENT_ID")
    private Category parent;

    @OneToMany(mappedBy = "parent")
    private List<Category> child = new ArrayList<>();

    @ManyToMany
    @JoinTable(name = "CATEGORY_ITEM",
        joinColumns = @JoinColumn(name = "CATEGORY_ID"),
        inverseJoinColumns = @JoinColumn(name = "ITEM_ID"))
    private List<Item> items = new ArrayList<>();

	...
}

 

 

※ N:M 관계는 1:N, N:1 로

 

테이블의 N:M 관계는 중간 테이블을 이용해서 1:N, N:1 꼴로 변경한다.

실전에서는 중간 테이블이 단순하지 않다.

@ManyToMany 는 필드를 추가할 수 없고 엔티티 테이블 불일치에 대한 제약이 존재한다.

 

 

※ @JoinColumn 

 

외래키를 매핑할 때 사용한다.

- name : 매핑할 외래키 이름

- referencedColumnName : 외래키가 참조하는 대상 테이블의 칼럼명

- foreignKey(DDL) : 외래키 제약조건을 직접 지정할 수 있으며 테이블을 생성할 때만 사용한다.

 

 

※ @ManyToOne

 

다대일 관계를 매핑한다.

- optional : false 로 설정하면 연관된 엔티티가 항상 있어야 한다.

- fetch : 글로벌 페치 전략을 설정한다. (ex : FetchType.EAGER, FetchType.LAZY)

- cascade : 영속성 전이 기능을 사용한다.

 

 

※ @OneToMany

 

다대일 관계를 매핑한다.

- mappedBy : 연관관계의 주인 필드를 선택한다.

- fetch : 글로벌 페치 전략을 설정한다.

- cascade : 영속성 전이 기능을 사용한다.