[JPA] 7장. 고급 매핑

[tonykang22]

7장. 고급 매핑

상속 관계 매핑

• 관계형 데이터베이스에는 객체지향 언어에서 다루는 상속이라는 개념이 없다.
  • 대신 슈퍼타입 서브타입 관계라는 모델링 기법이 객체의 상속 개념과 가장 유사하다.
• 슈퍼타입 서브타입 논리 모델을 실제 물리 모델인 테이블로 구현하는 방법으로는 3 가지가 존재한다.
  • 각각의 테이블로 변환 : 각각을 모두 테이블로 만들고 조회할 때 조인을 사용한다. 조인 전략
  • 통합 테이블로 변환 : 테이블을 하나만 사용해 통합한다. 단일 테이블 전략
  • 서브타입 테이블로 변환 : 서브 타입마다 하나의 테이블을 만든다. 테이블 전략

조인 전략

• 엔티티 각각을 모두 테이블로 만들고, 자식 테이블이 부모 테이블의 기본 키를 받아서 기본 키 + 외래 키로 사용하는 전략
  • 조회할 때 조인을 자주 사용한다.
  • 주의할 점 : 객체와 달리 테이블은 타입의 개념이 없기 때문에 타입을 구분하는 컬럼을 추가해야한다.
    • 예시에서는 DTYPE 컬럼이 해당 기능을 담당

예시

• @Inheritance(strategy = InheritanceType.JOINED)
  • 상속 매핑은 부모 클래스에 @Inheritance를 사용해야 한다.
  • 매핑 전략은 조인을 사용하므로 InheritanceType.JOINED를 적용
• @DiscriminatorColumn(name = "DTYPE")
  • 부모 클래스에 구분 컬럼을 지정한다.
  • 해당 컬럼으로 저장된 자식 테이블을 구분할 수 있다.
• @DiscriminatorValue("M")
  • 엔티티를 저장할 때 구분 컬럼에 입력할 값을 지정한다.
• @PrimaryKeyJoinColumn(name = "BOOK_ID")
  • 자식 테이블은 부모 테이블의 ID 컬럼명을 그대로 사용하는게 기본이다.
  • 해당 애노테이션을 통해 기본 키 컬럼명을 변경 가능
  • 장점
    • 테이블 정규화 / 외래 키 참조 무결성 제약조건 활용 가능 / 저장공간 효율적으로 사용
  • 단점
    • 조회 시 많은 조인 사용으로 성능 저하 / 복잡한 조회 쿼리 / 데이터 등록할 INSERT SQL 두 번 실행

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

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

    private String name; 
    private int price;
    ...
}

@Entity
@DiscriminatorValue("A")
public class Album extends Item {

    private String artist;
    ...
}

@Entity
@DiscriminatorValue("M")
public class Movie extends Item {

    private String director;
    ...
}

단일 테이블 전략

• 이름 그대로 테이블 하나만 사용하는 전략이다.
  • 구분 컬럼으로 어떤 자식 데이터가 저장되었는지 구분한다.
  • 조회할 때 조인을 사용하지 않으므로 일반적으로 가장 빠르다.
• 단일 테이블 전략 사용 시 주의점
  • 자식 엔티티가 매핑한 컬럼은 모두 null을 허용해야 한다는 점이다.
• 단일 테이블 전략 장점
  • 조인이 필요 없으므로 일반적으로 조회 성능이 빠르다.
  • 조회 쿼리가 단순하다.
• 단일 테이블 전략 단점
  • 자식 엔티티가 매핑한 컬럼은 모두 null을 허용해야 한다.
  • 단일 테이블에 모든 것을 저장하므로 테이블이 커질 수 있다.
    • 상황에 따라서 조회 성능이 오히려 느려질 수도 있다.

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

• 구현 클래스마다 테이블 전략은 자식 엔티티마다 테이블을 만들어 사용한다.
• 구현 클래스마다 테이블 전략 장점
  • 서브 타입을 구분해서 처리할 때 효과적이다.
  • not null 제약조건을 사용할 수 있다.
• 구현 클래스마다 테이블 전략 단점
  • 여러 자식 테이블을 함께 조회할 때 성능이 느리다. (SQL에 UNION을 사용해야 한다.)
  • 자식 테이블을 통합해서 쿼리하기 어렵다.

@MappedSuperclass

• 부모 클래스는 테이블과 매핑하지 않으면서, 부모 클래스를 상속받는 자식 클래에게 매핑 정보만 제공하고 싶을 때 사용한다.
  • @Entity는 실제 테이블과 매핑되지만, @MappedSuperclass는 실제 테이블과는 매핑되지 않는다.
  • 단순히 매핑 정보를 상속할 목적으로만 사용된다.
• 등록일, 수정일 같이 여러 엔티티에서 공통으로 사용하는 매핑 정보만 상속받고 싶으면 이 기능을 사용하면 된다.
• @MappedSuperclass로 지정한 클래스는 엔티티가 아니므로 em.find()나 JPQL에서 사용할 수 없다.
  • 해당 클래스는 직접 생성해 사용할 일이 거의 없으므로 추상 클래스로 만드는 것을 권장한다.

예시

• Member와 Seller 엔티티에 공통으로 필요한 ID, NAME 정보를 BaseEntity라는 공통 매핑 정보로 묶어내었다.

@MappedSuperclass
public abstract class BaseEntity {

    @Id @GeneratedValue
    private Long id;
    private String name;
    ...
}

// 부모로부터 물려받은 매핑 정보를 재정의하려면 아래와 같이 사용할 수 있다.
// @AttributeOverride(name = "id", column = @Column(name = "MEMBER_ID"))
@Entity
public class Member extends BaseEntity {

    // ID, NAME 상속
    private String email;
    ...
}

@Entity
public class Seller extends BaseEntity {

    // ID, NAME 상속
    private String shopName;
    ...
}

복합 키와 식별 관계 매핑

• 데이터베이스의 식별자가 하나 이상일 때 매핑하는 방법을 다뤄보자.

식별 관계 vs 비식별 관계

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

식별 관계

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

비식별 관계

• 부모 테이블의 기본 키를 받아서 자식 테이블의 외래 키로만 사용하는 관계다.
• 비식별 관계는 외래 키에 NULL을 허용하는지에 따라 필수적 비선별 관계와 선택적 비선별 관계로 나눈다.
  • 필수적 비선별 관계(Mandatory): 외래 키에 NULL을 허용하지 않는다. 연관관계를 필수로 맺어야한다.
  • 선택적 비선별 관계(Optional): 외래 키에 NULL을 허용한다. 연관관계를 맺을지 말지 선택할 수 있다.

조인 테이블

• 데이터베이스 테이블의 연관관계를 설계하는 방법은 크게 2가지다.
  • 조인 컬럼 사용 (외래 키)
  • 조인 테이블 사용 (테이블 사용)

일대일 조인 테이블

• 일대일 관계를 만드려면 조인 테이블의 외래 키 컬럼 각각에 총 2개의 유니크 제약조건을 걸어야 한다.

예시

• 부모 엔티티를 보면 @JoinColumn 대신 @JoinTable을 사용했다.
• @JoinTable의 속성은 다음과 같다.
  • name : 매핑할 조인 테이블 이름
  • joinColumns : 현재 엔티티를 참조하는 외래 키
  • inverseJoinColumns : 반대방향 엔티티를 참조하는 외래 키

@Entity
public class Parent {

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

    @OneToOne
    @JoinTable(name = "PARENT_CHILD",
            joinColumns = @JoinColumn(name = "PARENT_ID"),
            inverseJoinColumns = @JoinColumn(name = "CHILD_ID"))
    private Child child;

    ...
}

@Entity
public class Child {

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

일대다 조인 테이블

예시

@Entity
public class Parent {

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

    @OneToMany
    @JoinTable(name = "PARENT_CHILD",
            joinColumns = @JoinColumn(name = "PARENT_ID"),
            inverseJoinColumns = @JoinColumn(name = "CHILD_ID"))
    private List<Child> child = new ArrayList<>();

    ...
}

@Entity
public class Child {

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

다대일 조인 테이블

예시

@Entity
public class Parent {

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

    @OneToMany(mappedBy = "parent")
    @JoinTable(name = "PARENT_CHILD",
            joinColumns = @JoinColumn(name = "PARENT_ID"),
            inverseJoinColumns = @JoinColumn(name = "CHILD_ID"))
    private List<Child> child = new ArrayList<>();

    ...
}

@Entity
public class Child {

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

    @ManyToOne(optional = false)
    @JoinTable(name = "PARENT_CHILD",
            joinColumns = @JoinColumn(name = "CHILD_ID"),
            inverseJoinColumns = @JoinColumn(name = "PARENT_ID"))
    private Parent parent;
    ...
}

대다대 조인 테이블

예시

@Entity
public class Parent {

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

    @ManyToMany
    @JoinTable(name = "PARENT_CHILD",
            joinColumns = @JoinColumn(name = "PARENT_ID"),
            inverseJoinColumns = @JoinColumn(name = "CHILD_ID"))
    private List<Child> child = new ArrayList<>();

    ...
}

@Entity
public class Child {

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

엔티티 하나에 여러 테이블 매핑

• @SecondaryTable을 사용하면 한 엔티티에 여러 테이블을 매핑할 수 있다.
  • 예시를 통해 알아보자

예시

• Board 엔티티는 @Table을 이용해 BOARD 테이블과 매핑했다.
• @SecondaryTable을 사용해 BOARD_DETAIL 테이블을 추가로 매핑했다.
  • @SecondaryTable.name: 매핑할 다른 테이블 이름
  • @SecondaryTable.pkJoinColumns: 매핑할 다른 테이블의 기본 키 컬럼 속성

@Entity
@Table(name = "BOARD")
@SecondaryTable(name = "BOARD_DETAIL",
        pkJoinColumns = @PrimaryKeyJoinColumn(name = "BOARD_DETAIL_ID"))
public class Parent {

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

    private String title;

    @Column(table = "BOARD_DETAIL")
    private String content;
    ...
}

정리