복합 키와 식별관계 매핑

복합 키과 식별 관계 매핑

복합 키를 매핑하는 방법과 식벽관계, 비식별 관계를 매핑하는 방법을 알아보겠습니다.

식별관계 vs 비식별 관계

데이터베이스 테이블 사이에 관계는 외래 키가 기본 키에 포함되는지 여부에 따라 식별 관계와 비식별 관계로 구분됩니다. 두 관계의 특징을 이해하고 각각을 어떻게 매핑하는지 알아봅시다.

식별관계

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

위의 그림을 보면 PARENT 테이블의 기본 키 PARENT_ID를 받아서 CHILD 테이블의 기본키 (PK) + 외래 키(FK)로 사용합니다.

비식별 관계

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

PARENT 테이블의 기본 키 PARENT_ID를 받아서 CHILD 테이블의 외래 키(FK)로만 사용한다.
비식별 관계는 외래 키에 NULL을 허용하는지에 따라 필수적 비식별 관게와 선택적 비식별 관계로 나눕니다.

• 필수적 비식별 관계: 외래키에 NULL을 허용하지 않습니다. 연관관계를 필수적으로 맺어야 합니다.

• 선택적 식별 관계: 외래키에 NULL을 허용합니다. 연관관계를 맺을지 말지 선택할 수 있습니다.

최근에는 테이블을 설계할 때 식별 관계나 비식별 관계 중 하나를 선택해야 합니다.
최근에는 비식별 관계를 주로 사용하고 꼭 필요한 곳에만 식별 관계를 사용하는 추세입니다.
JPA는 식별 관계와 비식별 관계를 모두 지원합니다.

복합 키: 비식별 관계 매핑

둘 이상의 컬럼으로 구성된 복합 기본 키는 아래 코드처럼 매핑하면 될 것 같지만 막상 해보면 매핑 오류가 발생합니다. JPA에서는 식별자를 둘 이상 사용하려면 별도의 식별자 클래스가 필요하기 때문입니다.

@Entity
public class Hello{

    @Id
    private String id1;
    @Id
    private String id2; // 실행 시점에 매핑 예외발생

}

JPA는 영속성 컨텍스트에 엔티티를 보관할 때 엔티티의 식별자를 키로 사용합니다. 그리고 식별자를 구분하기 위해 equals와 hashCode를 사용해서 동등성 비교를 합니다. 그런데 식별자 필드가 하나일 때는 보통 자바의 기본타입을 사용하므로 문제가 없지만, 식별자 필드가 2개 이상이면 별도의 식별자 클래스를 만들고 그곳에 equals와 hashCode를 구현해야 합니다.

JPA는 복합 키를 지원하기 위해 @IdClass와 @EmbeddedId 2가지 방법을 제공하는데 @IdClass는 관계형 데이터베이스에 가까운 방법이고 @EmbeddedId는 좀 더 객체지향에 가까운 방법입니다. 먼저 @IdClass부터 알아봅시다.

@IdClass

복합 키 테이블은 비식별 관계이고 PARENT는 복합 기본 키를 사용합니다. 참고로 여기서 이야기하는 부모 자식은 객체의 상속과는 무관합니다. 단지 테이블의 키를 내려받는 것을 강조하려고 이름을 이렇게 지었습니다.

PARENT 테이블을 보면 기본 키를 PARENT_ID1, 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와 연결

    private String name;

}

public class ParentId implements Serializable{

    private String id1; // Parent.id1 매핑
    private String id2; // Parent.id2 매핑

    public ParentId(){}



    public ParentId(String id1, String id2)}
        this.id1 = id1;
        this.id2 = id2;
    }

    @Override
    public boolean equals(Object obj) { ... }

    @Override
    public int hashCode() {...}

}

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

• 식별자 클래스의 속성명과 엔티티에서 사용하는 식별자의 속성명이 같아야 합니다.
  실제로 코드를 보면 Parent.id1과 Parent.id2, 그리고 ParentId.id1, ParentId.id2가 같습니다.

• Serializable 인터페이스를 구현해야 합니다.

• equals, hashCode를 구현해야 합니다.

• 기본 생성자가 있어야 합니다.

• 식별자 클래스는 public이어야 합니다.

실제 어떻게 사용하는지 코드로 살펴보겠습니다. 먼저 복합 키를 사용하는 엔티티를 저장합니다.

    @Test
    @Transactional
    @Rollback(false)
    public void 식별자_테스트() throws Exception {

        //given
        Parent parent = new Parent();
        parent.setId1("myId1");
        parent.setId2("myId2");
        parent.setName("parentName");

        //when
        em.persist(parent);
        ParentId parentId = new ParentId("myId1", "myId2");

        //복합 키로  조회
        Parent findParent = em.find(Parent.class, parentId);
        //then
        System.out.println(findParent.getId1() + " " + findParent.getId2() + " " + findParent.getName());
     }

저장 코드를 보면 식별자 클래스인 ParentId가 보이지 않는데, em.persist()를 호출하면 영속성 컨텍스트에 엔티티를 등록하기 직전에 내부에서 Parent.id1, Parent.id2 값을 사용해서 식별자 클래스인 ParentId를 생성하고 영속성 컨텍스트의 키로 사용합니다.

아래 코드는 자식 클래스를 추가하였습니다.

@Getter
@Setter
@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

@IdClass가 데이터베이스에 맞춘 방법이라면 @EnbeddedId는 좀 더 객체지향적인 방법입니다.

@EqualsAndHashCode
@Embeddable
public class ParentId implements Serializable {

    @Column(name = "PARENT_ID1")
    private String id1; // Parent.id1 매핑
    @Column(name = "PARENT_ID2")
    private String id2; // Parent.id2 매핑

    public ParentId(){}


    public ParentId(String id1, String id2){
        this.id1 = id1;
        this.id2 = id2;
    }
}


@Setter
@Getter
@Entity
@IdClass(ParentId.class)
public class Parent {

    @EmbeddedId
    ParentId parentId;

    private String name;

}

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

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

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

@EmbeddedId를 사용하는 코드를 보겠습니다.

    @Test
    @Transactional
    @Rollback(false)
    public void 식별자_테스트() throws Exception {

        Parent parent = new Parent();
        ParentId parentId = new ParentId("myId1", "myId2");
        parent.setParentId(parentId);
        parent.setName("parentName");

        em.persist(parent);

        ParentId parentId1 = new ParentId("myId1", "myId2");
        Parent findParent = em.find(Parent.class, parentId1);

        System.out.println(findParent.getName());
     }

위의 코드를 보면 식별자 클래스 parentId를 직접 생성해서 사용합니다.

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

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

김영한의 JAVA ORM 표준 JPA 프로그래밍