[자바 ORM 표준 JPA 프로그래밍] 7장. 고급 매핑

Backend/JPA

[자바 ORM 표준 JPA 프로그래밍] 7장. 고급 매핑

anxi 2024. 2. 22. 17:30

7.1 상속 관계 매핑

7.1.1 조인 전략 _ 각각의 테이블로 변환

엔티티 각각을 모두 테이블로 만들고 자식 테이블이 부모 테이블의 기본 키를 받아서 기본 키 + 외래 키로 사용하는 전략
조회할 때 조인을 자주 사용한다.
타입을 구분하는 컬럼을 추가해야한다. (객체는 타입으로 구분할 수 있지만 테이블은 타입의 개념이 없기 때문)

// 부모 클래스
@Entity
// 부모 클래스에 @Inheritance를 사용한다. 
// 조인 전략을 사용하므로 InheritanceType.JOINED를 사용한다.
@Inheritance(strategy = InheritanceType.JOINED)
// 부모 클래스에 구분 컬럼을 지정한다. 
// 이 컬럼(DTYPE)을 통해 저장된 자식 테이블을 구분할 수 있다.
@DiscriminatorColumn(name = "DTYPE")
public abstract class Item {
	
    @Id @GeneratedValue
    @Column(name = "ITEM_ID")
    private Long id;
    
    private String name; // 이름
    ...
}

// 자식 클래스
@Entity
@DiscriminatorValue("A")
public class Album extends Item {
	
    private String artist;
    ...
}

기본값으로 자식 테이블은 부모 테이블의 ID 컬럼명을 그대로 사용한다.
만약 자식 테이블의 기본 키 컬럼명을 변경하고 싶으면 @PrimaryKeyJoinColumn을 사용한다.

// 자식 클래스
@Entity
@DiscriminatorValue("A")
@PrimaryKeyJoinColumn(name = "ALBUM_ID")
public class Album extends Item {
	
    private String artist;
    ...
}

장점
- 테이블이 정규화된다.
- 외래 키 참조 무결성 제약조건을 활용할 수 있다.
- 저장공간을 효율적으로 사용한다.
단점
- 조회할 때 조인이 많이 사용되므로 성능 저하가 발생할 수 있다.
- 조회 쿼리가 복잡하다.
- 데이터를 등록할 INSERT SQL을 두 번 실행한다.
관련 어노테이션
- @PrimaryKeyJoinColumn, @DiscriminatorColumn, @DiscriminatorValue

7.1.2 단일 테이블 전략 _ 통합 테이블로 변환

이름 그대로 테이블을 하나만 사용한다.
구분 컬럼으로 어떤 자식 데이터가 저장되었는지 구분한다.
조회할 때 조인을 사용하지 않으므로 일반적으로 가장 빠르다.

// 부모 클래스
@Entity
// 부모 클래스에 @Inheritance를 사용한다. 
// 단일 테이블 전략을 사용하므로 InheritanceType.SINGLE_TABLE를 사용한다.
@Inheritance(strategy = InheritanceType.SINGLE_TABLE)
// 부모 클래스에 구분 컬럼을 지정한다. 
// 이 컬럼(DTYPE)을 통해 저장된 자식 테이블을 구분할 수 있다.
@DiscriminatorColumn(name = "DTYPE")
public abstract class Item {
	
    @Id @GeneratedValue
    @Column(name = "ITEM_ID")
    private Long id;
    
    private String name; // 이름
    private String artist;
    ... 이외 자식 엔티티가 매핑한 모든 컬럼
}

// 자식 클래스
@Entity
@DiscriminatorValue("A")
public class Album extends Item {}

...

장점
- 조인이 필요없으므로 조회 성능이 빠르다.
- 조회 쿼리가 단순하다.
단점
- 자식 엔티티가 매핑한 컬럼은 모두 null을 허용해야 한다.
- 단일 테이블에 모든 것을 저장하므로 테이블이 커질 수 있다. -> 조회 성능이 오히려 느려질 수 있다.
특징
- 구분 컬럼을 꼭 사용해야 한다. (@DiscriminatorColumn)
- @DiscriminatorValue를 지정하지 않으면 기본으로 엔티티 이름을 사용한다.

7.2 @MappedSuperclass

부모 클래스는 테이블과 매핑하지 않고 부모 클래스를 상속받는 자식 클래스에게 매핑 정보만 제공하고 싶을 때 사용한다.
실제 테이블과는 매핑되지 않는다.

@MappedSuperclass
public abstract BaseEntity {
	
    @Id @GeneratedValue
    private Long id;
    
    private String name;
    ...
}

@Entity
public class Member extends BaseEntity {
	
    // Id 상속
    // Name 상속
    private String email;
    ...
}

@Entity
public class Seller extends BaseEntity {
	
    // Id 상속
    // Name 상속
    private String shopName;
    ...
}

부모로부터 물려받은 매핑 정보를 재정의하려면 @AttributeOverrides 나 @AttributeOverride 를 사용한다.

// 1개 재정의
@Entity
@AttributeOverride(name = "id", column = @Column(name = "MEMBER_ID"))
public class Member extends BaseEntity { ... }

// 2개 이상 재정의
@Entity
@AttributeOverrides({
	@AttributeOverride(name = "id", column = @Column(name = "MEMBER_ID")),
    ...
})
public class Member extends BaseEntity { ... }

특징
- 테이블과 매핑되지 않고 자식 클래스에 엔티티의 매핑 정보를 상속하기 위해 사용한다.
- @MappedSuperclass로 지정한 클래스는 엔티티가 아니므로 em.find() 나 JPQL에서 사용할 수 없다.
- 이 클래스를 직접 생성해서 사용할 일은 거의 없으므로 추상 클래스로 만드는 것을 권장한다.

7.3 복합 키와 식별 관계 매핑

7.3.1 식별 관계 vs 비식별 관계

식별 관계
- 부모 테이블의 기본 키를 내려받아서 자식 테이블의 기본 키 + 외래 키로 사용하는 관계
비식별 관계
- 부모 테이블의 기본 키를 받아서 자식 테이블의 외래 키로만 사용하는 관계 (자식 테이블의 독립된 기본 키가 존재)
- 필수적 비식별 관계 : 외래 키(부모 테이블)에 NULL을 허용하지 않는다. (필수로 연관관계 맺어야 함)
- 선택적 비식별 관계 : 외래 키에 NULL을 허용한다. (연관관계 또한 선택할 수 있다.)
- 최근에는 비식별 관계를 주로 사용하고 꼭 필요한 곳에만 식별관계를 사용한다.

7.3.2 복합 키 : 비식별 관계 매핑

@Entity
public class Hello {
	@Id
    private String id1;
    
    @Id
    private String id2; // 실행 시점에 매핑 예외 발생
}

위와 같이 복합키를 매핑할 경우 오류가 발생한다.
@IdClass와 @EmbeddedId 2가지 방법을 이용하여 복합 키를 매핑한다.

@IdClass - 데이터베이스에 맞춘 방법

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 o) {...}
    
    @Override
    public int hashCode() {...}
}

@IdClass를 사용할 때 만족해야 할 조건
- 식별자 클래스의 속성명과 엔티티에서 사용하는 식별자의 속성명이 같아야 한다.
- Serializable 인터페이스를 구현해야 한다.
- equals, hashCode를 구현해야 한다.
- 기본 생성자가 있어야 한다. (lombok : @NoArgsConstructor 이용)
- 식별자 클래스는 public이어야 한다.

@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은 생략해도 된다.

@IdClass - 객체지향적인 방법

@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 and hashCode 구현
    ...
}

@EmbeddedId를 사용할 때 만족해야할 조건
- @Embeddable 어노테이션을 붙여줘야 한다.
- Serializable 인터페이스를 구현해야 한다.
- equals, hashCode를 구현해야 한다.
- 기본 생성자가 있어야 한다. (lombok : @NoArgsConstructor)
- 식별자 클래스는 public이어야 한다.

7.3.3 복합 키 : 식별 관계 매핑

식별 관계에서 자식 테이블은 부모 테이블의 기본 키를 포함해서 복합 키를 구성해야 한다.

@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;
    
    private String name;
    ...
}

//자식 ID
public class ChildId implements Serializable {
	
    private String parent; // Child.parent 매핑
    private String childId; // Child.childId 매핑
    
    //equals and hashCode
    ...
}

//손자
@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;
    
    private String name;
    ...
}

//손자 ID
public class GrandChildId implements Serializable {
	
    private ChildId child; //GrandChild.child 매핑
    private String id; //GrandChild.id 매핑
    
    //equals and hashCode
    ...
}

@EmbeddedId와 식별 관계

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

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

//자식 ID
@Embeddable
public class ChildId implements Serializable {
	
    private String parentId; //@MapsId("parentId")로 매핑
    
    @Column(name = "CHILD_ID")
    private String id;
    
    //equals and hashCode
    ...
}

//손자
@Entity
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
@Embeddable
public class GrandChildId implements Serializable {
	
    private ChildId childId; //@MapsId("childId")로 매핑
    
    @Column(name = "GRANDCHILD_ID")
    private String id;
    
    //equals and hashCode
    ...
}

7.3.4 비식별 관계로 구현

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

//자식
@Entity
public class Child {
	
    @Id @GeneratedValue
    @Column(name = "CHILD_ID")
    private Long id;
    
    @ManyToOne
    @JoinColumn(name = "PARENT_ID")
    public Parent parent;
    
    private String name;
    ...
}

//손자
@Entity
public class GrandChild {
	
    @Id @GeneratedValue
    @Column(name = "GRANDCHILD_ID")
    private Long id;
    
    @ManyToOne
    @JoinColumn(name = "CHILD_ID")
    private Child child;
    
    private String name;
    ...
}

7.3.5 일대일 식별 관계

//부모
@Entity
public class Board {
	
    @Id @GeneratedValue
    @Column(name = "BOARD_ID")
    private Long id;
    
    private String title;
    
    @OneToOne(mappedBy = "board")
    private BoardDetail boardDetail;
    ...
}

//자식
@Entity
public class BoardDetail {
	
    @Id
    private Long boardId;
    
    @MapsId //BoardDetail.boardId 매핑
    @OneToOne
    @JoinColumn(name = "BOARD_ID")
    private Board board;
    
    private String content;
    ...
}

정리
- 비식별 관계를 사용하고 기본 키는 Long 타입의 대리 키를 사용한다.
이유 : 대리 키는 비즈니스와 아무 관련이 없어 비즈니스가 변경되어도 유연한 대처가 가능하다.

7.4 조인 테이블

데이터베이스 테이블의 연관관계를 설계하는 방법은 크게 2가지다.

조인 컬럼 사용(외래 키)
조인 테이블 사용(테이블 사용)

기본은 조인 컬럼을 사용하고 필요하다고 판단되면 조인 테이블을 사용하자 !

7.4.1 일대일 조인 테이블

//부모
@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;
    ...
}

@JoinTable의 속성
- name : 매핑할 조인 테이블 이름
- joinColumns : 현재 엔티티를 참조하는 외래 키
- inverseJoinColumns : 반대 방향 엔티티를 참조하는 외래키

7.4.2 일대다 조인 테이블

//부모
@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;
    ...
}

7.4.3 다대일 조인 테이블

//부모
@Entity
public class Parent {
	
    @Id @GeneratedValue
    @Column(name = "PARENT_ID")
    private Long id;
    private String name;
    
    @OneToMany(mappedBy = "parent")
    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;
}

일대다 조인 테이블과 방향만 반대이다.

7.4.4 다대다 조인 테이블

//부모
@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;
    ...
}