[JPA] 고급 매핑 알아보기

 

* 해당 글은 김영한 강사님의 자바 ORM 표준 JPA 프로그래밍 - 기본 편을 보고 간단하게 정리한 글입니다.(자세한 내용은 강의가 최곱니다. 강의 사세요)

 

자바 ORM 표준 JPA 프로그래밍 - 기본편 강의 - 인프런

 

 

상속 관계 매핑

 

 

관계형 데이터베이스에는 객체 지향 언어의 상속이라는 개념이 없다. 대신 슈퍼타입, 서브타입이라는 모델링 기법이 그나마 비슷하여 대신 사용한다.

 

 

물론, 이를 실제 물리 모델인 테이블로 구현하기 위해 다음 세 가지 방법을 사용한다.

 

• 조인 전략
• 단일 테이블 전략
• 구현 클래스마다 테이블 전략

 

 

 

 

 

조인 전략

 

 

조인 전략은 부모 테이블의 기본 키를 받아서 기본 키 + 외래 키로 사용하는 전략이다.

 

 

이에 따라 부모 클래스는 아래와 같이 작성한다.

@Entity
@Inheritance(strategy = InheritanceType.JOINED)
@DiscriminatorColumn(name = "DTYPE")
public abstract class Item {

    @Id @GeneratedValue
    @Column(name = "ITEM_ID")
    private Long id;
    ...
}

 

굳이 구현할 클래스가 아니기 때문에 _abstract_로 접근 제어자를 지정한다. 또한 _@Inheritance_ 어노테이션의 _strategy_ 속성 값을 위와 같이 _InheritanceType.JOINED_로 설정한다.

 

 

_@DiscriminatorColumn_은 저장된 자식 테이블을 구분할 수 있는 구분 컬럼이다. 기본 값은 _DTYPE_이다.

 

 

자식 클래스는 아래와 같다.

@Entity
@DiscriminatorValue("A")
public class Album extend Item {
   ....
}

 

 

앞서 설정해 주었던 구분 컬럼인 _@DiscriminatorColumn_에 들어갈 값을 설정하기 위해 _@DiscriminatorValue_를 작성한다. 그리고 Item 클래스를 상속받으면 끝이다.

 

 

조인 전략을 사용했을 때의 장점은 저장 공간을 효율적으로 사용할 수 있으며 테이블이 정규화되고, 외래 키 참조 무결성을 제약 조건을 활용할 수 있다.

 

 

반면, 조회 시에 쿼리가 더 나가서 성능이 저하될 수 있다.

 

 

 

 

 

 

단일 테이블 전략

 

 

말 그대로 테이블을 하나만 사용하는 것이다. 조인을 사용하지 않아 일반적으로 가장 빠르다.

 

 

앞선 코드에서 부모 테이블 코드에 _@Inheritance_의 속성인 _strategy_를 _InheritanceType.SINGLE_TABLE_로 바꾸어주면 된다.

 

 

또한 테이블이 하나이기에 자식 테이블을 구분하기 위하여 _@DiscriminatorColumn_을 꼭 써야 한다.

 

 

 

 

 

구현 클래스마다 테이블 전략

 

 

말 그대로 구현 클래스마다 테이블을 생성하는 전략이다. 이 전략은 자식 엔티티마다 테이블을 만든다. 일반적으로 자주 사용하지는 않는다.

 

 

앞선 것과 마찬 가지로 _InheritanceType.TABLE_PER_CLASS_로 바꾸어주자.

 

 

 

 

 

 

 

MappedSuperclass

 

_MappedSuperclass_는 부모 클래스를 테이블과 매핑하지 않고, 오직 그 자식 클래스에게 매핑 정보만을 제공하고 싶을 때 사용한다.

 

 

즉, 객체들이 주로 사용하는 공통 매핑 정보만을 정의하고 자식들은 그저 이를 물러 받아 사용하면 되는 것이다.

 

 

사용하는 방법은 간단하다. 아래처럼 부모 클래스에 _@MappedSuperclass_를 붙이고 자식은 그냥 상속받으면 된다.

 

@MappedSuperclass
public abstract class BaseEntity {
...
}

 

 

추가적으로 만약 부모에게 상속받은 id 명을 바꾸고 싶다면 _@AttributeOverride(name = "id", column = @Column(name = "MEMBER ID"))_와 같이 사용할 수 있다.

 

 

 

 

 

 

 

복합 키와 식별 관계 매핑

 

 

 

식별 관계 vs 비식별 관계

 

• 식별 관계
  • 부모 테이블의 기본 키를 받아서 자식 테이블의 기본 키 + 외래 키로 사용하는 것
• 비식별 관계
  
  • 부모 테이블의 기본 키를 받아서 자식 테이블의 외래 키로만 사용하는 것
  • 필수적 비식별 관계
    • 외래 키에 NULL을 허용하지 않음
  • 선택적 비식별 관계
    • 외래 키에 NULL을 허용하는 것

 

 

 

 

 

복합 키, 비식별 관계 매핑

 

JPA에서 복합 키를 지원하는 방법에는 두 가지가 있다.

 

 

하나는 _@IdClass_, 그리고 다른 하나는 _@EmbeddedId_이다. 여기서 _@IdClass_는 관계형 데이터베이스에 가까운 방법이고, _@EmbeddedId_는 객체지향에 조금 더 가까운 방법이다. 

 

 

 

IdClass에 대한 방법

 

먼저 _@IdClass_에 대한 방법이다.

 

 

부모 클래스는 아래와 같이 작성한다.

 

부모 클래스

@Entity
@IdClass(ParentId.class)
public class Parent {
    
    @Id
    @Column(name = "PARENT_ID")
    private String id1;
    
    @Id
    @Column(name = "PARENT_ID")
    private String id2;
    ...
}

 

 

_@IdClass_에는 식별자 클래스를 작성해야 한다.

 

식별자 클래스

public class ParentId implements Serializable {
    
    private String id1;
    private String id2;
    
    public ParentId() {
    }
    // equals, hashcode 구현
}

 

 

식별자 클래스는 속성 명이 엔티티에서 사용하는 식별자 속성 명과 같아야 한다. 또한 위와 같이 _Serializable_을 상속받아야 한다.

 

 

해당 복합 키는 둘다 PK이기 때문에 이를 상속받는 자식 클래스는 비식별로 설정하기 때문에 아래와 같이 구현해야 한다.

 

자식 클래스

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

 

 

 

 

EmbeddedId에 대한 방법

 

 

다음은 _@EmbeddedId_에 대한 방법이다.

 

부모 클래스

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

 

 

식별자 클래스

@Embeddable
public class ParentId implements Serializable {

    @Column(name = "PARENT_ID1")
    private String id1;
    
    @Column(name = "PARENT_ID2")
    private String id2;
    // equals, hashcode 구현
}

 

 

앞선 _@IdClass_와의 차이점은 _@EmbeddedId_부모 엔티티를 저장할 때 식별자 클래스를 직접 생성한다는 것이다.

 

Parent parent = new Parent();
ParentId = new ParentId("myId1", "myId2");
parent.setId(ParentId);
...

 

 

_@EmbeddedId_와 _@IdClass_는 사실 취향 껏 사용하면 된다. _@EmbeddedId_는 조금 더 객체지향적이지만, JPQL 쿼리가 더 나간다는 점을 알아두자.

 

 

 

복합 키, 식별 관계 매핑

 

 

IdClass에 대한 방법

 

부모 클래스

@Entity
public class Parent {

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

 

 

자식 클래스

@Entity
@IdClass(ChildId.class)
public class Child {

    @Id
    @ManyToOne
    @JoinColumn(name = "PARENT_ID")
    public Parent parent;
    
    @Id @Column(name = "CHILD_ID")
    private String childId;
    ...
}

 

 

식별이므로, FK에 _@Id_로 설정해주어 FK + PK로써 역할을 할 수 있도록 한다. 또한 Child 클래스가 복합 키를 가지고 있게 되므로 식별자 클래스도 작성해 주자.

 

 

식별자 클래스

public class ChildId implements Serializable {

    private String parent;
    private String childId;
    
    // equals, hashcode 구현
}

 

 

만약에 이렇게 식별 관계의 복합 키를 지닌 Child 클래스의 자식인 GrandChild가 있다고 해보자.

 

 

손자 클래스

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

 

손자 클래스도 마찬가지로 FK + PK를 사용해 주며 복합 키를 이루기 때문에 _@IdClass_를 사용해 줄 수 있다.

 

 

 

EmbeddedId와 식별관계

 

 

부모 클래스

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

 

 

자식 클래스

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

 

 

식별관계 복합키를 표현하기 위해서 _@EmbeddedId_를 사용하는데, 이때 PK이자 FK의 역할을 해줄 PARENT_ID를 _@MapsId_로 등록해 준다.

 

 

식별자 클래스

@EmbeddedId
public class ChildId implements Serializable {
    
    private String parentId; // @MapsId로 매핑된다.
    
    @Column(name = "CHILD_ID")
    private String id;
    
    // equals, hashCode
    ...
}

 

 

_@MapsId_를 통해 매핑된 parentId는 PK로써 역할을 수행할 수 있게 된다. 또한 복합키이기에 위와 같이 식별자 클래스를 작성해 준다.

 

 

손자 클래스

@Entity
public class GrandChild {
    
    @EmbeddedId
    private GrandChildId id;
    
    @MapsId("childId")
    @ManyToOne
    @JoinColumns({
        @JoinColumn(name = "PARENT"),
        @JoinColumn(name = "CHILD_ID")
    })
    private Child chlid;
}

 

 

손자 식별자 클래스

@Embeddable
public class GrandChildId implements Serializable {

    private ChildId childId;
    
    @Column(name = "GRANDCHILD_ID")
    private String id;
    
    // equals, hashcode
}

 

 

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

 

 

 

 

 

일대일 식별관계

 

 

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

 

 

부모 클래스

@Entity
public class Board {
    
    @Id @GenerateValue
    @Column(name = "BOARD_ID")
    private Long id;
    
    private String title;
    
    @OneToMany(mappedBy = "board")
    private BoardDetail boardDetail;
}

 

 

자식 클래스

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

 

 

 

 

식별 vs. 비식별

 

 

식별 관계는 기본 키 컬럼이 늘어나고 조인 시에 SQL이 복잡해진다. 또한 복합키를 만들어야 하는 상황도 자주 발생한다. 

 

"비식별 관계를 사용하고, 기본 키는 Long 타입의 대리 키를 사용하자."

 

또한 필수적 비식별 관계를 사용하는 것이 좋은데, 이는 조인 시에 외부 조인이 아닌 내부 조인(inner join)을 사용하게 되므로 NOT NULL을 보장하기 때문이다.

 

 

 

 

 

 

 

조인 테이블

 

 

데이터베이스 테이블의 연관관계를 설계하는 방법은 크게 두 가지로 조인 컬럼(외래 키)을 사용하거나 조인 테이블(테이블)을 사용하는 방법으로 나뉜다.

 

 

조인 컬럼은 이전까지 우리가 사용한 _@JoinColumn_을 사용하면 되고, 조인 테이블을 _@JoinTable_을 사용한다.

 

 

조인 테이블을 사용하는 이유는 다대다 관계를 해결하는 것도 있지만, 외래 키 기반으로 설계했을 때 NULL값이 많이 저장되는 상황을 피하기 위해 사용한다. 즉, 일대일, 다대일, 일대다 상황에서도 충분히 사용할 수 있다.

 

 

 

자바 ORM 표준 JPA 프로그래밍 - 기본편 강의 - 인프런