[JPA] 복합 키와 식별 관계 매핑

식별관계와 비식별 관계

데이터베이스 테이블 사이에 관계는 외래 키가 기본 키에 포함되는지 여부에 따라 식별 관계와 비식별 관계로 구분된다.

식별 관계

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

비식별 관계

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

비식별 관계는 외래 키에 NULL을 허용하는지에 따라 필수적 비식별 관계와 선택적 비식별 관계로 나눈다.

• 필수적 비식별 관계(Mandatory) : 외래 키에 NULL을 허용하지 않는다. 연관관계를 필수적으로 맺어야 한다.
• 선택적 비식별 관계(Optional) : 외래 키에 NULL을 허용한다. 연관관계를 맺을지 말지 선택할 수 있다.

데이터베이스 테이블을 설계할 때 식별 관계나 비식별 관계 중 하나를 선택해야 한다.

최근에는 비식별 관계를 주로 사용하고 꼭 필요한 곳에만 식별 관계를 사용하는 추세다.

---

복합 키 - 비식별 관계 매핑

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

그리고 식별자를 구분하기 위해 equals와 hashCode를 사용해서 동등성 비교를 한다.

식별자 필드가 하나일 때는 보통 자바의 기본 타입을 사용하므로 문제가 없지만, 식별자 필드가 2개 이상이면 별도의 식별자 클래스를 만들고 그곳에 equals와 hashCode를 구현해야 한다.

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

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

---

@IdClass

@Entity
@AllArgsConstructor
@NoArgsConstructor
@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와 연결
    
    private String name;
}

@AllArgsConstructor //전체 생성자
@NoArgsConstructor //기본 생성자
@EqualsAndHashCode //equals,hashCode
public class ParentId implements Serializable {
    private String id1;
    private String id2;
}

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

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

@Test
@Transactional
void idClassTest() {
	//저장
	Parent parent = new Parent("myId1", "myId2","bright-star");
	em.persist(parent);

	//조회
	ParentId parentId = new ParentId("myId1", "myId2");
	Parent findParent = em.find(Parent.class, parentId);

	//검증
	log.info("parent = {}", parent);
	log.info("findParent = {}", findParent);
	Assertions.assertThat(parent).isEqualTo(findParent);
}

저장 코드를 보면 식별자 클래스인 ParentId가 보이지 않는데, em.persist()를 호출하면 영속성 컨텍스트에 엔티티를 등록하기 직전에 내부에서

Parent.id1, Parent.id2 값을 사용해서 식별자 클래스인 ParentId를 생성하고 영속성 컨텍스트의 키로 사용한다.

 

조회 코드를 보면 식별자 클래스인 ParentId를 사용해서 엔티티를 조회한다.

자식 클래스를 추가해보자.

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

부모 테이블의 기본 키 컬럼이 복합 키이므로 자식 테이블의 외래 키도 복합키다.

따라서 외래 키 매핑 시 여러 컬럼을 매핑해야 하므로 @JoinColumns 어노 테이션을 사용하고 각각의 외래 키 컬럼을 @JoinColumn으로 매핑한다.

참고로 @JoinColumn의 name 속성과 referencedColumnName 속성의 값이 같으면 referencedColumnName은 생략해도 된다.

---

@EmbeddedId

@Entity
@AllArgsConstructor
@NoArgsConstructor
public class Parent {

    @EmbeddedId
    private ParentId id;

    private String name;
}

@AllArgsConstructor //전체 생성자
@NoArgsConstructor //기본 생성자
@EqualsAndHashCode //equals, hashCode
@Embeddable
public class ParentId implements Serializable {

    @Column(name = "PARENT_ID1")
    private String id1;
    @Column(name = "PARENT_ID2")
    private String id2;
}

@IdClass와 다르게 @EmbeddedId를 적용한 식별자 클래스는 식별자 클래스에 기본 키를 직접 매핑한다.

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

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

@Test
@Transactional
void embeddedIdTest() {
	//저장
	ParentId parentId = new ParentId("myId1", "myId2");
	Parent parent = new Parent(parentId, "bright-star");
	em.persist(parent);

	//조회
	ParentId parentId2 = new ParentId("myId1", "myId2");
	Parent findParent = em.find(Parent.class, parentId2);

	//검증
	log.info("parent = {}", parent);
	log.info("findParent = {}", findParent);
	Assertions.assertThat(parent).isEqualTo(findParent);
}

---

복합 키와 equals(), hashCode()

영속성 컨텍스트는 엔티티의 식별자를 키로 사용해서 엔티티를 관리한다.

그리고 식별자를 비교할 때 equals()와 hashCode()를 사용한다. 따라서 식별자 객체의 동등성(equal 비교)이 지켜지지 않으면 예상과 다른 엔티티가 조회되거나 엔티티를 찾을 수 없는 등 영속성 컨텍스트가 엔티티를 관리하는 데 심각한 문제가 발생한다.  따라서 복합 키는 equals()와 hashCode()를 필수로 구현해야 한다.

---

@IdClass vs @EmbeddedId

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

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

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

복합 키에는 @GenerateValue를 사용할 수 없다. 복합 키를 구성하는 여러 컬럼 중 하나에도 사용할 수 없다.

---

복합 키 - 식별 관계 매핑

식별 관계에서 자식 테이블은 부모 테이블의 기본 키를 포함해서 복합 키를 구성해야 하므로 @IdClass나 @EmbbedId를 사용해서 식별자를 매핑해야 한다.

---

@IdClass

//부모
@Entity
@AllArgsConstructor
@NoArgsConstructor
public class Parent {

    @Id @Column(name = "PARENT_ID")
    private String id;
    private String name;
}

//자식
@Entity
@NoArgsConstructor
@AllArgsConstructor
@IdClass(ChildId.class)
public class Child {

    @Id
    @ManyToOne
    @JoinColumn(name = "PARENT_ID")
    private Parent id;

    @Id @Column(name = "CHILD_ID")
    private String childId;
    private String name;
}

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

//손자
@Entity
@NoArgsConstructor
@AllArgsConstructor
@IdClass(GrandChildId.class)
public class GrandChild {
    @Id
    @ManyToOne
    @JoinColumns({
            @JoinColumn(name = "PARENT_ID"),
            @JoinColumn(name = "CHILD_ID")
    })
    private Child child;

    @Id @Column(name = "GRANDCHILD_ID")
    private String id;
    private String name;
}

//손자 ID
@EqualsAndHashCode
@NoArgsConstructor
@AllArgsConstructor
public class GrandChildId implements Serializable {
    private ChildId childId; //GrandChild.child 매핑
    private String id; //GrandChild.id 매핑
}

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

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

@Id
@ManyToOne
@JoinColumn(name = "PARENT_ID")
private Parent id;

---

@EmbeddedId

@EmbeddedId로 식별 관계를 구성할 때는 @MapsId를 사용해야 한다.

//부모
@Entity
@AllArgsConstructor
@NoArgsConstructor
public class Parent {

    @Id @Column(name = "PARENT_ID")
    private String id;
    private String name;
}

//자식
@Entity
@NoArgsConstructor
@AllArgsConstructor
public class Child {

    @EmbeddedId
    private ChildId id;

    @MapsId("parentId") //ChildId.parentId 매핑
    @ManyToOne
    @JoinColumn(name = "PARENT_ID")
    private Parent parent;

    private String name;
}

//자식 ID
@EqualsAndHashCode
@NoArgsConstructor
@AllArgsConstructor
@Embeddable
public class ChildId implements Serializable {
    private String parentId; //@MapsId("parentId")로 매핑

    @Column(name = "CHILD_ID")
    private String id; //Child.childId 매핑
}

//손자
@Entity
@NoArgsConstructor
@AllArgsConstructor
@IdClass(GrandChildId.class)
public class GrandChild {

    @EmbeddedId
    private GrandChildId id;

    @MapsId("childId") //GrandChildId.childId 매핑
    @ManyToOne
    @JoinColumns({
            @JoinColumn(name = "PARENT_ID"),
            @JoinColumn(name = "CHILD_ID")
    })
    private Child child;
    private String name;
}

//손자 ID
@EqualsAndHashCode
@NoArgsConstructor
@AllArgsConstructor
@Embeddable
public class GrandChildId implements Serializable {
    private ChildId childId; //@MapsId("childId")로 매핑

    @Column(name = "GRANDCHILD_ID")
    private String id;
}

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

@MapsId("parentId") //ChildId.parentId 매핑
@ManyToOne
@JoinColumn(name = "PARENT_ID")
private Parent parent;

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

@MapsId는 왜래 키와 매핑한 연관관계를 기본 키에도 매핑하겠다는 뜻이다.

@MapsId의 속성 값은 @EmbeddedId를 사용한 식별자 클래스의 기본 키 필드를 지정하면 된다.

---

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

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

• 식별 관계는 부모 테이블의 기본 키를 자식 테이블로 전파하면서 자식 테이블의 기본 키 컬럼이 점점 늘어난다.
• 식별 관계는 2개 이상의 컬럼을 합해서 복합 기본키를 만들어야 하는 경우가 많다.
• 식별 관계를 사용할 때 기본 키로 비즈니스 의미가 있는 자연 키 컬럼을 조합하는 경우가 많다.
• 식별 관계는 부모 테이블의 기본 키를 자식 테이블의 기본 키를 사용하므로 비식별 관계보다 테이블 구조가 유연하지 못하다.

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

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

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

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

 

ORM 신규 프로젝트 진행 시 추천하는 방법은 될 수 있으면 비식별 관계를 사용하고 기본 키는 Long 타입의 대리키를 사용하는 것이다.

그리고 선택적 비실별 관계보다는 필수적 비식별 관계를 사용하는 것이 좋은데, 선택적인 비식별 관계는 NULL을 허용하므로 조인할 때에 외부 조인을 사용해야 한다.

---

참고 자료 :

https://ebook-product.kyobobook.co.kr/dig/epd/ebook/E000003140954

자바 ORM 표준 JPA 프로그래밍 | 김영한 | 에이콘출판- 교보ebook