복합 키와 식별, 비식별 관계 매핑

복합키

JPA는 영속성 컨텍스트에 엔티티를 보관할 때 엔티티의 식별자를 키로 사용한다.

식별자 필드가 2개 이상이면 별도의 식별자 클래스를 만들어 식별자를 구분해야 한다.

JPA는 복합 키를 지원하기 위해 @IdClass와 @EmbeddedId 2가지 방법을 제공한다.

@IdClass는 관계형 데이터베이스에 가까운 방법이고, @EmbeddedId는 좀 더 객체 지향에 가까운 방법이다.

복합키 매핑에 예제에서 확인해보자 

---

복합 키: 식별 관계(Identifying Relationship) 매핑

식별 관계는 부모 테이블의 기본 키를 내려받아서 자식 테이블의 기본 키 + 외래 키로 사용하는 관계다.

식별 관계

PARENT 테이블의 기본 키 PARENT_ID를 받아서 CHILD 테이블의 기본 키(CHILD_ID) + 외래 키(PARENT_ID)로 사용한다.

@IdClass

@Entity
public class Parent {
    @Id
    @Column(name = "PARENT_ID")
    private STring id;  
}


@EqualsAndHashCode
@NoArgsConstructor
@AllArgsConstructor
public class ChildId implements Serializable {
    private String parent; // Child.parent 매핑
    private String childId; // Child.childId 매핑
}

@Entity
@IdClass(ChildId.class)
public class Child {
    @Id
    @ManyToOne
    @JoinColumn(name = "PARENT_ID")
    private Parent parent;
    
    @Id
    @Column(name = "CHILD_ID")
    private String childId;
}


@EqualsAndHashCode
@NoArgsConstructor
@AllArgsConstructor
public class GrandChildId implements Serializable {
    private ChildId child; // GrandChild.child 매핑
    private String grandChildId; // GrandChild.grandChildId 매핑
}

@Entity
@IdClass(GrandChildId.class)
public class GrandChild {
    @Id
    @ManyToOne
    @JoinColumns({
    	@JoinColumn(name = "PARENT_ID"),
        @JoinColumn(name = "CHILD_ID")
    })
    private Child child;
    
    @Id
    @Column(name = "CHILD_ID")
    private String grandChildId;
}

식별 관계는 기본 키와 외래 키를 같이 매핑해야 한다.

식별자 매핑인 @Id와 연관관계 매핑인 @ManyToOne을 같이 사용하면 된다.

@EmbeddedId

@Entity
public class Parent {
    @Id
    @Column(name = "PARENT_ID")
    private STring id;  
}


@Embeddable
@EqualsAndHashCode
@NoArgsConstructor
@AllArgsConstructor
public class ChildId implements Serializable {
    private String parentId; // @MapsId("parentId")로 매핑
    @Column(name = "CHILD_ID")
    private String childId;
}

@Entity
public class Child {
    @MapsId("parentId") // ChildId.parentId와 매핑
    @ManyToOne
    @JoinColumn(name = "PARENT_ID")
    private Parent parent;
    
    @EmbeddedId
    private ChildId id;
}


@Embeddable
@EqualsAndHashCode
@NoArgsConstructor
@AllArgsConstructor
public class GrandChildId implements Serializable {
    private String childId; // @MapsId("childId")로 매핑
    @Column(name = "GRAND_CHILD_ID")
    private String grandChildId;
}

@Entity
public class GrandChild {
    @MapsId("childId") // GrandChildId.childId와 매핑
    @ManyToOne
    @JoinColumns({
    	@JoinColumn(name = "PARENT_ID"),
        @JoinColumn(name = "CHILD_ID")
    })
    private Child child;
    
    @EmbeddedId
    private GrandChildId id;
}

@EmbeddedId는 실별 관계로 사용할 연관관계의 속성에 @MapsId를 사용하면 된다.

@IdClass와 다른 점은 @Id 대신에 @MapsId를 사용한 점이다.

@MapsId는 외래키와 매핑한 연관관계를 기본 키에도 매핑하겠다는 뜻이다. 속성 값은 @EmbeddedId를 사용한 식별자 클래스의 기본 키 필드를 지정하면 된다. 

---

복합 키: 비식별 관계(Non-Identifying Relationship) 매핑

비식별 관계는 부모 테이블의 기본 키를 받아서 자식 테이블의 외래 키로만 사용하는 관계다.

비식별 관계에는 필수적 비식별 관계와 선택정 비식별 관계가 있다.

비식별 관게

필수적 비식별 관계(Mandatory)

외래 키에 NULL을 허용하지 않는다. 연관관계를 필수적으로 맺어야 한다.

 

선택적 비식별 관계(Optional)

외래 키에 NULL을 허용한다. 연관관계를 맺을지 말지 선택할 수 있다.

@IdClass

@EqualsAndHashCode
@NoArgsConstructor
@AllArgsConstructor
public class ParentId implements Serializable {
    private String id1; // Parent.id1 매핑
    private String id2; // Parent.id2 매핑
}

@Entity
@IdClass(ParentId.class)
public class Parent {
    @Id
    @Column(name = "PARENT_ID1")
    private String id1; // ParentId.id1 매핑
    
    @Id
    @Column(name = "PARENT_ID2")
    private String id2; // ParentId.id2 매핑
}


@Entity
public class Child {
    @Id
    private String id;

    @ManyToOne
    @JoinColumns({
            @JoinColumn(name = "PARENT_ID1", referencedColumnName = "PARENT_ID1"),
            @JoinColumn(name = "PARENT_ID2", referencedColumnName = "PARENT_ID2")
    })
    private Parent parent;
}

@IdClass를 이용해 복합 키를 설정하고 @JoinColumns를 이용하여 Child 클래스와 매핑하였다.

@IdClass를 사용할 때 식별자 클래스는 다음 조건을 만족해야 한다.

• 식별자 클래스의 속성명과 엔티티에서 사용하는 식별자의 속성명이 같아야 한다.
  (Parent.id1 = ParentId.id1, Parent.id2 = ParentId.id2)
• Serializable 인터페이스를 구현해야 한다.
• equals, hashCode를 구현해야 한다.
• 기본 생성자가 있어야 한다.
• 식별자 클래스는 public이어야 한다.

@EmbeddedId

@Embeddable
@EqualsAndHashCode
@NoArgsConstructor
@AllArgsConstructor
public class ParentId implements Serializable {
    @Column(name = "PARENT_ID1")
    private String id1;
    @Column(name = "PARENT_ID2")
    private String id2;
}


@Entity
public class Parent {
    @EmbeddedId
    private ParentId id;
}

@EmbeddedId를 사용할 때 식별자 클래스는 다음 조건을 만족해야 한다.

• @Embeddable 어노테이션을 사용해야 한다.
• Serializable 인터페이스를 구현해야 한다.
• equals, hashCode를 구현해야 한다.
• 기본 생성자가 있어야 한다.
• 식별자 클래스는 public이어야 한다.

---

@IdClass vs @EmbeddedId

@IdClass와 @EmbeddedId는 각각 장단점이 있으므로 본인의 취향에 맞는 것을 일관성있게 사용하면 된다.

@EmbeddedId가 @IdClass와 비교해서 더 객체지향적이고 중복도 없어서 좋아보이긴 하지만 특정 상황에 JPQL이 조금 더 길어질 수 있다.

"select p.id.id1, p.id.id2 from Parent p" // @EmbeddedId
"select p.id1, p.id2 from Parent p"); // @IdClass

---

비식별 관계(Non-Identifying Relationship)로 구현

@Entity
public class Parent {
    @Id 
    @GeneratedValue
    @Column(name = "PARENT_ID")
    private Long id;
}


@Entity
public class Child {
    @Id 
    @GeneratedValue
    @Column(name "CHILD_ID")
    private Long id;
	
    @ManyToOne
    @JoinColumn(name = "PARENT_ID")
    private Parent parent;
}


@Entity
public class GrandChild {
    @Id 
    @GeneratedValue
    @Column(name = "GRANDCHILD_ID")
    private Long id;
	
    @ManyToOne
    @JoinColumn(name = "CHILD_ID")
    private Child child;
}

식별 관계의 복합 키를 사용한 코드와 비교하면 매핑도 쉽고 코드도 단순하다.

그리고 복하키가 없으므로 복합 키 클래스를 만들지 않아도 된다.

---

일대일 식별 관계(Identifying Relationship)

일대일 식별 관계는 자식 테이블의 기본 키 값으로 부모 테이블의 기본 키 값만 사용한다.

그래서 부모 테이블의 기본 키가 복합 키가 아니면 자식 테이블의 기본 키는 복합 키로 구성하지 않아도 된다.

@Entity
public class Board {
    @Id 
    @GeneratedValue
    @Column(name = "BOARD_ID")
    private Long id;
	
    @OneToOne(mappedBy = "board")
    private BoardDetail boardDetail;
}


@Entity
public class BoardDetail {
    @Id
    private Long boardId;
	
    @MapsId // BoardDetail.boardId 매핑
    @OneToOne
    @JoinColumn(name = "BOARD_ID")
    private Board board;
}

BoardDetail처럼 식별자가 단순히 컬럼 하나면 @MapsId를 사용하고 속성 값은 비워두면 된다.

이때 @MapsId는 @Id를 사용해서 식별자로 지정한 BoardDetail.boardId와 매핑한다.

일대일 식별 관계를 어떻게 저장하는지 아래에서 확인할 수 있다.

// 일대일 식별 관계 저장
public void save() {
    Board board = new Board();
    board.setTitle("제목");
    em.persist(board);
    
    BoardDetail boardDetail = new BoardDetail();
    boardDetail.setContent("내용입니다~");
    boardDetail.setBoard(board);
    em.persist(boardDetail);
}

---

식별, 비식별 관계의 장단점

데이터베이스 설계 관점에서 보면 다음과 같은 이유로 식별 관계보다는 비식별 관계를 선호한다.

• 식별 관계는 부모 테이블의 기본 키를 자식 테이블로 전파하기 때문에 기본 키 컬럼이 점점 늘어나게 된다.(자식 테이블) 결국 조인할 때 SQL이 복잡해지고 기본 키 인덱스가 불필요하게 커질 수 있다.
• 식별 관계는 2개 이상의 컬럼을 합해서 복합 기본 키를 만들어야 하는 경우가 많다.
• 식별 관계를 사용할 때 기본 키로 비즈니스 의미가 있는 자연 키 컬럼을 조합하는 경우가 많다.
  반면에 비식별 관계의 기본 키는 비즈니스와 전혀 관계없는 대리 키를 주로 사용한다.
  비즈니스 요구사항은 언제든 바뀔수 있어야 하므로 전혀 상관없는 비식별 관계로 매핑하는 것이 유리하다.

객체 관계 매핑의 관점에서 보면 다음과 같은 이유로 비식별 관계를 선호한다.

• 일대일 관계를 제외하고 식별 관계는 2개 이상의 컬럼을 묶은 복합 기본 키를 사용한다.
  JPA에서 복합 키는 별도의 복합 키 클래스를 만들어서 사용해야 한다. 따라서 컬럼이 하나인 기본 키를 매핑하는 것보다 많은 리소스가 필요하다.
• 비식별 관계의 기본 키는 주로 대리 키를 사용하는 JPA는 @GenerateValue처럼 대리 키를 생성하기 위한 편리한 방법을 제공한다.

 

물론 식별 관계가 가지는 장점도 있다.

기본키 인덱스를 활용하기 좋고, 상위 테이블들의 기본 키 컬럼을 자식, 손자 테이블들이 가지고 있으므로 특정 상황에 조인 없이 하위 타에블만으로 검색 할 수 있다.

 

 

 

정리해보자면,
데이터베이스 테이블 사이에 관계는 외래 키가 기본 키에 포함되는지 여부에 따라 식별 관계와 비식별 관계로 구분한다. 최근에는 비식별 관계를 주로 사용하고 꼭 필요한 곳에만 식별 관계를 사용하는 추세다.
ORM 신규 프로젝트 진행 시 추천하는 방법은 될 수 있으면 비식별 관계를 사용하고 기본 키는 long 타입의 대리 키를 사용하는 것이다. 그리고 선택적 비식별 관계(LEFT, RIGNT, OUTER JOIN)보다는 필수적 비식별 관계(INNER)를 사용하는 것이 좋다.