JPA 고급 매핑

[emiling]

JPA 고급 매핑

출처 : 자바 ORM 표준 JPA 프로그래밍 7장 JPA 시작(김영한 저)

[emiling]

상속관계 매핑

조인전략

• 엔티티 각각을 모두 테이블로 만든 뒤
• 자식 테이블이 부모 테이블의 기본 키를 받아 기본키 + 외래키로 사용하여 조인
• 만약 자식 테이블의 기본키 컬럼을 변경하고자 할 때는 @PrimaryKeyValueJoinColumn 를 사용한다

예시

// 상품 (부모 클래스)
@Entity
@Inheritence(strategy = Inheritance.JOINED)
@DiscriminatorColumn(name = "DTYPE")
abstract class Product(
    @Id @GeneratedValue
    @Column(name = "product_id")
    val id: Long,
    val name: String? = null,
    val price: Int? = null
)

// 앨범 (자식 클래스)
@Entity
@DiscriminatorValue("A")
class Album(
    val artist: String?
): Product

// 영화 (자식 클래스)
@Entity
@DiscriminatorValue("M")
class Movie(
    val director: String?
    val actor: String?
): Product

// 책 (자식 클래스)
@Entity
@DiscriminatorValue("B")
@PrimaryKeyValueJoinColumn(name = "book_id")
class Book(
    val author: String?
    val isbn: String?
): Product

장단점

• 테이블 정규화 되고, 외래키 참조 무결성 제약조건 활용 가능하며, 저장공간 효율적으로 사용가능하다
• 그러나 조회할 때 많은 조인으로 성능저하가 발생할 수 있고, 조회쿼리가 복잡하며, 데이터 등록 시 INSERT SQL을 두번 실행한다

단일 테이블 전략

• 테이블을 하나로만 사용하여 구분컬럼(DTYPE)으로 어떤 자식 데이터가 저장되어 있는지 구분 가능하다
• 조회할 때 조인을 사용하지 않으므로 일반적으로 가장 빠르다
• 또한 하나의 테이블을 공유하기 때문에 자식 엔티티가 매핑한 컬럼은 모두 null을 허용해야 한다

예시

// 상품 (부모 클래스)
@Entity
@Inheritence(strategy = Inheritance.SINGLE_TABLE)
@DiscriminatorColumn(name = "DTYPE")
abstract class Product(
    @Id @GeneratedValue
    @Column(name = "product_id")
    val id: Long,
    val name: String? = null,
    val price: Int? = null
)

// 앨범 (자식 클래스)
// ... 위와 동일

// 영화 (자식 클래스)
// ... 위와 동일

// 책 (자식 클래스)
// ... 위와 동일

장단점

• 조인이 필요 없으므로 일반적으로 조회 성능이 빠르고 조회 쿼리가 단순하다
• 그러나 자식 엔티티가 매핑한 컬럼은 모두 null 허용해야하며, 단일테이블에 저장하기 때문에 테이블이 커질 수 있다.
  • 이런 경우 오히려 조회 성능이 떨어질 수 있다

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

• 자식 엔티티마다 테이블을 만들고 자식 테이블 각각에 필요한 컬럼이 모두 있는 형태이다

예시

@Entity
@Inheritence(strategy = Inheritance.TABLE_PER_CLASS)
abstract class Product(
    @Id @GeneratedValue
    @Column(name = "product_id")
    val id: Long,
    val name: String? = null,
    val price: Int? = null
)

// 앨범 (자식 클래스)
// ... 위와 동일

// 영화 (자식 클래스)
// ... 위와 동일

// 책 (자식 클래스)
// ... 위와 동일

장단점

• 서브 타입을 구분해서 처리할 때 효과적이며 not null 제약조건을 사용할 수 있다
• 여러 자식 테이블을 함께 조회할 때 성능이 느리다 (SQL UNION 연산)
• 자식 테이블을 통합해서 쿼리하기 어렵다
• DBA와 ORM 전문가가 모두 추천하지 않는 방식 😅

@MappedSuperClass

• 위의 세가지 방식은 부모 클래스와 자식 클래스를 모두 데이터베이스에 매핑했지만
• 부모 클래스를 테이블과 매핑하지 않고 자식 클래스에게 매핑 정보만 제공하고 싶을 때 사용한다
• @Entity 는 실제 테이블에 매핑되지만 @MappedSuperClass의 경우 실제 테이블과 매핑되지 않고 매핑 정보 상속을 위해 사용된다

[emiling]

상속관계 매핑 (2)

부모 클래스 매핑 하지 않는 경우

• 위의 세가지 방식은 부모 클래스와 자식 클래스를 모두 데이터베이스에 매핑했지만
• @MappedSuperClass는 부모 클래스를 테이블과 매핑하지 않고 자식 클래스에게 매핑 정보만 제공하고 싶을 때 사용한다
• 실제 테이블에 매핑되는 @Entity 와 달리, 실제 테이블과 매핑되지 않고 매핑 정보 상속을 위해 사용된다

예시

@MappedSuperclass
class BaseEntity(
    @Id
    @GeneratedValue
    var id: Long = 0,
    val name: String? = null
)

@Entity
data class User(
    val email: String?
): BaseEntity()

@Entity
data class Seller(
    val shopName: String?
): BaseEntity()

• 만약 부모에게 상속받은 속성명을 변경하고자 한다면 아래와 같이 AttributeOverride를 사용한다

  @Entity
  @AttributeOverrides(
  AttributeOverride(name = "id", column = Column(name = "user_id")),
  AttributeOverride(name = "name", column = Column(name = "user_name"))
  )
  data class User(val email: String?): BaseEntity() {}

• 간단히 말해서 엔티티가 공통으로 사용하는 매핑 정보를 모아주는 역할
  • 보통 등록일자, 수정일자, 등록자, 수정자 등과 같은 여러 엔티티에서 공통으로 사용하는 속성을 효과적으로 사용 가능하다
• 추가로 @MappedSuperclass로 지정한 클래스는 엔티티가 아니므로 em.find 나 JPQL 에서 사용 불가능하다
• 이 클래스를 직접 생성해서 사용할 일이 없으므로 추상 클래스로 만들어서 사용하는 것을 권장한다

[emiling]

복합키와 식별관계 매핑

식별관계 VS 비식별관계

• 식별관계 : 부모 테이블의 기본키를 받아 자식 테이블에서 PK+FK 구조로 사용
• 비식별관계 : 부모 테이블의 기본키를 FK로 받고 자식 테이블에서 따로 PK 정의해서 사용
  • 필수적 비식별관계 : FK에 NULL을 허용하지 않으므로 연관관계를 필수적으로 맺어야함 (조인 시 내부 조인으로 사용 가능)
  • 선택적 비식별관계 : FK에 NULL을 허용하므로 연관관계를 맺을지 말지 선택 가능함 (조인 시 외부 조인 필요)
• 최근에는 비식별 관계를 주로 사용하고 꼭 필요한 곳에만 식별 관계를 사용하는 추세

복합키

• JPA에서 영속성 컨텍스트에 엔티티를 보관할 때 엔티티의 식별자를 키로 사용한다
• 이 때 식별자를 구분하기 위해서 equals와 hashCode를 사용하여 동등성 비교를 하는데
• 식별자 필드가 두개 이상이면 별도의 클래스로 두 키를 묶어서 식별자 클래스를 만들어 위의 두 함수를 구현해서 사용해야 한다
• 추가로 복합키에는 @GeneratedValue를 사용할 수 없으며 복합키를 구성하는 여러 컬럼 중 하나에도 사용할 수 없다

복합키 : 비식별 관계 매핑

IdClass 사용

• 좀 더 데이터베이스 테이블에 가까운 방법

@Entity
@IdClass(ParentId::class)
data class Parent(
    @Id
    @Column("parent_id1")
    val id1: String,
    @Id
    @Column("parent_id2")
    val id2: String,
    @Column("name")
    val name: String
)

data class ParentId(
    val id1: String,
    val id2: String
) : Serializable

@Entity
data class Child(
    @Id
    val id: String,
    @ManyToOne
    @JoinColumns(
        // 이렇게 두 컬럼이 동일하면 referencedColumnName 생략 가능
        JoinColumn(name = "parent_id1", referencedColumnName = "parent_id1"), 
        JoinColumn(name = "parent_id2", referencedColumnName = "parent_id2")
    )
    val parent: Parent? = null
)

• 실제 저장할 때는 ParentId 를 따로 생성하지 않고 Product.id1과 Product.id2 를 넣어주고 em.persist 호출한다
• em.persist 를 호출하면 영속성 컨텍스트에 엔티티를 등록하기 직전에 ParentId 를 생성하고 영속성 컨텍스트의 키로 사용한다

EmbeddedId 사용

• 좀 더 객체지향적인 방법

@Entity
data class Parent(
    @EmbeddedId
    val id: ParentId,
    @Column(name = "name")
    val name: String
)

@Embeddable
data class ParentId(
    @Column(name = "parent_id1")
    val id1: String,
    @Column(name = "parent_id2")
    val id2: String
) : Serializable

• 실제 저장할 때는 ParentId 를 직접 생성해준 뒤에 저장해야 하고, 조회 시에도 ParentId 식별자 클래스를 직접 사용한다

복합키 : 식별 관계 매핑

IdClass 사용

• 식별 관계는 PK과 FK를 같이 매핑해야하기 때문에 @Id와 @ManyToOne을 같이 사용한다

@Entity
data class Parent(
    @Id @Column(name = "parent_id")
    val id: String
)

@Entity
@IdClass(ChildId::class)
data class Child(
    @Id
    @ManyToOne
    @JoinColumn(name = "parent_id")
    val parent: Parent,
    @Id @Column(name = "child_id")
    val childId: String,
)

data class ChildId(
    val parent: String, // Child.parent 매핑
    val childId: String // Child.childId 매핑
) : Serializable

@Entity
@IdClass(GrandChildId::class)
data class GrandChild(
    @Id
    @ManyToOne
    @JoinColumns(
        JoinColumn(name = "parent_id"),
        JoinColumn(name = "child_id"),
    )
    val child: Child,
    @Id @Column(name = "grandchild_id")
    val id: String,

)

@Embeddable
data class GrandChildId(
    val child: ChildId, // GrandChild.child 매핑
    val id: String // GrandChild.id 매핑
) : Serializable

EmbeddedId 사용

• 식별 관계로 사용할 연관관계의 속성에 @MapsId를 사용하면 된다
• 외래키와 매핑한 연관관계를 기본 키에도 매핑하넸다는 뜻

@Entity
data class Parent(
    @Id @Column(name = "parent_id")
    val id: String
)

@Entity
data class Child(
    @MapsId("parentId")
    @ManyToOne
    @JoinColumn(name = "parent_id")
    val parent: Parent,

    @EmbeddedId
    val childId: ChildId,
)

@Embeddable
data class ChildId(
    val parentId: String,
    @Column(name = "child_id")
    val id: String
) : Serializable

@Entity
data class GrandChild(
    @MapsId("childId")
    @ManyToOne
    @JoinColumns(
        JoinColumn(name = "parent_id"),
        JoinColumn(name = "child_id"),
    )
    val child: Child,

    @EmbeddedId
    val id: GrandChildId,

)

@Embeddable
data class GrandChildId(
    val childId: ChildId,
    @Column(name = "grandchild_id")
    val id: String
) : Serializable

비식별 관계로 구현

• 위의 식별관계 테이블을 아래와 같이 비식별 관계로 변경할 수 있다

@Entity
data class Parent(
    @Id @GeneratedValue
    @Column(name = "parent_id")
    val id: Long
)

@Entity
data class Child(
    @Id @GeneratedValue
    @Column(name = "parent_id")
    val id: Long,
    val name: String,
    @ManyToOne
    @JoinColumn(name = "parent_id")
    val parent: Parent
)

@Entity
data class GrandChild(
    @Id @GeneratedValue
    @Column(name = "parent_id")
    val id: Long,
    @ManyToOne
    @JoinColumn(name = "child_id")
    val child: Child
)

일대일 식별 관계

• 일대일 식별 관계는 자식 테이블의 기본키 값으로 부모 테이블의 기본키 값만 사용한다
• 따라서 부모 테이블의 기본키가 복합키가 아니면 자식 테이블의 기본키는 복합키로 구성하지 않아도 됨

@Entity
data class Board(
    @Id @GeneratedValue
    @Column(name = "board_id")
    val id: Long,
    val title: String,
    @OneToOne(mappedBy = "board")
    val boardDetail: BoardDetail
)

@Entity
data class BoardDetail(
    @Id
    val boardId: Long,
    @MapsId // BoardDetail.boardId 매핑
    @OneToOne
    @JoinColumn(name = "board_id")
    val board: Board,
    val content: String?
)