자바 ORM 표준 JPA 프로그래밍(8) - 다양한 연관관계 매핑

다중성

• 다대일: @ManyToOne
• 일대다: @OneToMany
• 일대일: @OneToOne
• 다대다: @ManyToMany

 

다대일

n:1 관계 매핑에 대해서는 앞 포스팅에 다루었기 때문에 이번 포스팅에서는 다루지 않겠음.

일대다

1:n 관계는 n:1 관계의 반대 방향이다. 1:n 관계는 엔티티를 하나 이상 참조할 수 있으므로 자바 컬렉션인 Collection, List, Set, Map 중에 하나를 사용해야 한다.

일대다 단방향

@Entity
public class Team {

    @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "team_id")
    private Long id;

    private String name;

    @OneToMany
    @JoinColumn(name = "member_id") // n:1 중 n이 되는 엔티티에 JoinColumn을 추가한다.
    private List<Member> members = new ArrayList<>();

    ...
}

• 일대다 단방향은 일대다(1:N)에서 일(1)이 연관관계의 주인
• 테이블 일대다 관계는 항상 다(N) 쪽에 외래 키가 있음
• 객체와 테이블의 차이 때문에 반대편 테이블의 외래 키를 관리하는 특이한 구조
• @JoinColumn을 꼭 사용해야 함. 그렇지 않으면 조인 테이블
  방식을 사용함(중간에 테이블을 하나 추가함)
• 본인 테이블에 외래 키가 없기 때문에 INSERT SQL 이후 연관관계 처리를 위한 UPDATE SQL을 추가로 실행함
• 엔티티를 매핑한 테이블이 아닌 다른 테이블의 외래 키를 관리하기 때문에 직관성이 떨어져 어플리케이션 관리에 단점을 보인다. 하여 다대일 양방향 매핑을 사용하는 것을 권장함.

 

일대일

• 일대일 관계는 그 반대도 일대일
• 주 테이블이나 대상 테이블 중에 외래 키 선택 가능
  • 주 테이블에 외래 키: 주 테이블만 확인해도 대상 테이블과 연관관계가 있는지 알 수 있음
  • 대상 테이블에 외래 키: 1:1에서 1:n으로 변경할 때 테이블 구조를 그대로 유지할 수 있음
• 외래 키에 데이터베이스 유니크(UNI) 제약조건 추가

 

주 테이블에 외래 키

주 테이블에 외래 키 단방향

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

 

주 테이블에 외래 키 양방향

• 다대일 양방향 매핑 처럼 외래 키가 있는 곳이 연관관계의 주인
• 반대편은 mappedBy 적용

 

대상 테이블에 외래 키

대상 테이블에 외래 키 단방향

• 단방향 관계는 JPA 지원X
• 양방향 관계는 지원

 

대상 테이블에 외래 키 양방향

• 사실 일대일 주 테이블에 외래 키 양방향과 매핑 방법은 같음

 

정리

주 테이블에 외래 키

• 주 객체가 대상 객체의 참조를 가지는 것 처럼 주 테이블에 외래 키를 두고 대상 테이블을 찾음
• 객체지향 개발자 선호
• JPA 매핑 편리
• 장점: 주 테이블만 조회해도 대상 테이블에 데이터가 있는지 확인 가능
• 단점: 값이 없으면 외래 키에 null 허용

 

대상 테이블에 외래 키

• 대상 테이블에 외래 키가 존재
• 전통적인 데이터베이스 개발자 선호
• 장점: 주 테이블과 대상 테이블을 일대일에서 일대다 관계로 변경할 때 테이블 구조 유지
• 단점: 프록시 기능의 한계로 지연 로딩으로 설정해도 항상 즉시 로딩됨(프록시는 추후에 학습)

 

다대다

• RDBMS에서 정규화된 테이블 2개로는 n:m 관계를 표현할 수 없고, 표현해서도 안 된다.
• 중간에 연결 테이블을 추가하여 1:n, m:1 관계로 풀어야한다.

 

객체는 테이블과 다르게 객체 2개로 n:m 관계를 만들 수 있다. 각자 컬렉션을 사용해 Member 객체는 Product를 참조하고 Product 객체도 Member를 참조하면 된다.

• @ManyToMany 사용
• @JoinTable로 연결 테이블 지정
• 다대다 매핑: 단방향, 양방향 가능

 

@Entity
public class Member {

    @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "member_id")
    private Long id;

    private String username;

    private int price;

    @ManyToMany
    @JoinTable(name = "MEMBER_PRODUCT", 
                joinColumns = @JoinColumn(name = "memeber_id"),
                inverseJoinColumns = @JoinColumn(name = "product_id")
            )
    private List<Product> products = new ArrayList<>();

    ...
}

@Entity
public class Product {

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

    private String name;

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

    ...
}

• @ManyToMany와 @JoinTable을 사용해 연결 테이블을 바로 매핑함
• 회원_상품(Member_Product) 엔티티 없이 매핑 가능
• @JoinTable 속성 설명
  • @JoinTable.name: 연결 테이블을 지정
  • @JoinTable.joinColumns: 현재 방향인 회원과 매핑할 조인 컬럼 정보를 지정
  • @JoinTable.inverseJoinColumns: 반대 방향인 상품과 매핑할 조인 컬럼 정보를 지정
• 반대편 엔티티에서 연관관계를 추가하고자 하면 @ManyToMany에 mappedBy 속성을 추가해 연관관계의 주인을 지정한다.

 

다대다 매핑의 한계

@ManyToMany를 이용하면 연결 테이블을 매핑할 엔티티를 구현하지 않아도 되기 때문에 도메인 모델도 단순해지고 편리하다. 하지만 실무에서 사용하기엔 한계가 있다. 예를 들어 연결 테이블에 주문 수량, 주문한 날짜와 같은 칼럼이 더 필요하다면 추가된 칼럼들을 매핑할 수 없기에 @ManyToMany는 사용할 수 없다.

다대다 한계 극복

@ManyToMany 사용의 한계를 극복하기 위해서는 연결 테이블을 엔티티로 승격하여 n:m 관계의 객체를 테이블 관계처럼 1:n, m:1로 풀어서 구현해야 한다. 여기서는 회원상품(MemberProduct) 엔티티를 추가한다.

객체의 1:n, m:1 관계를 구현하기 위해서 연결 테이블을 만들 때 식별자를 어떻게 구성할지 선택해야 한다.

• 식별 관계: 복합 기본 키 사용, 받아온 FK를 PFK로 사용한다.
• 비식별 관계: 새로운 기본 키 사용, 받아온 FK를 두고 새로운 PK를 사용한다.

 

여기서는 비식별 관계의 구현 방식만 다루도록 하겠다. 김영한 저자님의 경험상 식별 관계가 설계과정에서 정답에 가까운 것은 맞으나, 추후에 비즈니스 변경에 따른 유지보수의 유연성이 비식별 관계가 더 높기 때문에 비식별 관계 방식을 권장한다고 함. 또한 ORM으로 구현 시 엔티티 구성이 단순하고 편리해진다는 장점이 있다.

 

비식별 관계: 새로운 기본 키 사용

@Entity
public class Member {

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

    private String username;

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

@Entity
public class Product {

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

    private String name;

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

@Entity
public class Order {

    @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "order_id")
    private Long id;

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

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

    private int ordermount;

    private LocaleDateTime orderdate;
    ...
}