[Spring] 복합키 설정 방법 @EmbeddedId 구현, QueryDSL구현

hyewon jeong·2023년 2월 5일
Spring
0

Spring

목록 보기
34/65

본 글을 공부를 위해 참고자료를 참고하여 작성된 글입니다.

💡 복합 키와 식별 관계 매핑

식별 관계 vs 비식별 관계

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

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

비식별 관계
부모 테이블의 기본 키를 받아서 자식 테이블의 외래 키로만 사용하는 관계다.비식별관계비식별 관계는 외래 키에 NULL을 허용하는지에 따라 필수적/선택적 비식별 관계로 나뉜다.

📌 JPA는 영속성 컨텍스트에 엔티티를 보관할 때 엔티티의 식별자를 키로 사용한다. 그리고 식별자를 구분하기 위해 equals와 hashCode를 사용하여 동등성 비교를 한다. 그런데 식별자 필드가 하나일 때는 보통 자바의 기본 타입을 사용하므로 문제가 없지만,

📌 식별자 필드가 2개 이상이면 별도의

✅ 식별자 클래스를 만들고
✅ 그 곳에 equals와 hashCode를 구현해야 한다.

JPA는 복합 키를 지원하기 위해 @IdClass와 @EmbeddedId 2가지 방법을 제공한다.

🔑 @IdClass

관계형 데이터베이스에 더 가까운 방법으로 아래와 같이 사용된다.복합키테이블

@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를 사용하기 위한 식별자 클래스는 다음 조건을 만족해야 한다.

  1. 식별자 클래스의 속성명과 엔티티에서 사용하는 식별자의 속성명이 같아야 한다.(ex. Parent.id1과 ParentId.id1)
  2. Serializable 인터페이스를 구현해야 한다.
  3. equals, hashCode를 구현해야 한다.
  4. 식별자 클래스는 public 이어야 한다.
Parent parent = new Parent();
parent.setId1("myId1"); //  식별자
parent.setId2("myId2"); //  식별자
parent.setName("parentName");
em.persist(parent);

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

ParentId parentId = new ParentId("myId1", "myId2");
Parent parent = em.find(Parent.class, parentId);

복합 키로 parent 엔티티를 조회해오는 코드다.

@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

객체지향적인 방법으로 아래와 같이 사용된다.

@Entity
public class Parent {
    @EmbeddedId
    private ParentIdPK id;

    private String name;
    ...
}
@Embeddable
public class ParentIdPK implements Serializable {
    
    @Column(name = "PARENT_ID1")
    private String id1;

    @Column(name = "PARENT_ID2")
    private String id2;

    //  equals and hashCode 구현
    ...
}

✅ @EmbeddedId를 적용한 식별자 클래스는 식별자 클래스에 기본 키를 직접 매핑한다.

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

  1. @Embeddable 어노테이션을 붙여 줘야한다.
  2. Serializable 인터페이스를 구현해야 한다.
  3. equals, hashCode를 구현해야 한다.
  4. 기본 생성자가 있어야 한다.
  5. 식별자 클래스는 public 이어야 한다.
Parent parent = new Parent();
ParentIdPK parentId = new ParentIdPK("myId1", "myId2");
parent.setId(parentId);
parent.setName("parentName");
em.persist(parent);

위와 같이 저장하는 코드를 보면 식별자 클래스 parentId를 직접 생성해서 사용한다.

ParentIdPK parentId = new ParentIdPK("myId1", "myId2");
Parent parent = em.find(Parent.class, parentId);
조회 코드도 식별자 클래스 parentId를 직접 사용한다.

복합 키와 equals(), hashCode()
복합 키는 equals()와 hashCode()를 필수로 구현해야 한다.

Object 클래스에 구현된 equals()는 기본적으로 인스턴스 참조 값 비교인 == 비교(동일성 비교)를 하기 때문에 오버라이딩을 통해 동등성 비교가 가능하도록 구현이 필요하다.
영속성 컨텍스트는 기본적으로 엔티티의 식별자를 키로 사용해서 엔티티를 관리하고, 식별자를 비교할 때 equals()와 hashCode()를 사용하기 때문에 동등성이 지켜지지 않으면 예상과 다른 엔티티가 조회되거나 엔티티를 찾을 수 없는 등의 문제가 발생한다. 따라서 복합 키는 equals()와 hashCode()를 필수로 구현해야 한다.

@IdClass vs @EmbeddedId

특정 상황에 따라 @EmbeddedId를 사용했을 때 JPQL이 더 길어질 수 있다.

em.createQuery("select p.id.id1, p.id.id2 from Parent p");  //  @EmbeddedId
em.createQuery("select p.id1, p.id2 from Parent p");        //  @IdClass

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

💡 복합 키를 활용한 식별 관계 매핑

식별관계부모, 자식, 손자까지 계속 기본 키를 전달하는 식별 관계다. 식별 관계에서 자식 테이블은 부모 테이블의 기본 키를 포함해서 복합 키를 구성해야 하므로 @IdClass나 @EmbeddedId를 사용해서 식별자를 매핑해야 한다.

@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, 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, hashCode
    ...
}

식별 관계는 기본 키 + 외래 키 여야 하므로 @Id와 @ManyToOne을 같이 사용하여 매핑한다.

❤️ @EmbeddedId를 활용한 식별 관계

✅ 1. 엔티티 클래스 작성

@EmbeddedId를 활용하여 식별 관계를 구성할 때는 @MapsId를 사용해야 한다. @MapsId로 외래 키와 기본 키를 매핑하였다.
@MapsId의 속성 값은 @EmbeddedId를 사용한 식별자 클래스의 기본 키 필드를 지정한다.

@Entity
public class Mention {
  @EmbeddedId
  private MentionId mentionId;
  @ManyToOne 
  @MapsId("user_id")
  User user;

  @ManyToOne
  @MapsId("thread_id")
  Thread thread;
}
 //생성자
 @Builder
 public Mention(User user, Thread thread) {
    this.user = user;
    this.thread = thread;
  }

✅ 2. JPA 복합 키를 사용하려면 별도의 식별자 클래스를 만들어야 한다.

@EmbeddedId를 적용한 식별자 클래스는 식별자 클래스에 기본 키를 직접 매핑한다.

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

  1. @Embeddable 어노테이션을 붙여 줘야한다.
  2. Serializable 인터페이스를 구현해야 한다.
  3. equals, hashCode를 구현해야 한다.
  4. 기본 생성자가 있어야 한다.
  5. 식별자 클래스는 public 이어야 한다.
@Getter
@NoArgsConstructor(access = AccessLevel.PROTECTED)
@Embeddable
public class MentionId implements Serializable { //3


  @Column(name = "user_id")
  private Long userId;

  @Column(name = "thread_id")
  private Long thread_id;

  @Override
  public boolean equals(Object o) {
    if (this == o) {
      return true;
    }
    if (o == null || getClass() != o.getClass()))return false;
    UserChannelId userChannelId = (UserChannelId) o;
    return Objects.equals(getUserId(), userChannelId.getUserId()) && Objects.equals(getThread_id(),
        userChannelId.getChannelId());

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

  }

해당 클래스 이어서 작성
QueryDSL 이용법

profile
hyewon jeong
개발자꿈나무
이전 포스트

[Spring] equals와 hashCode는 왜 같이 재정의해야 할까?

다음 포스트

[Spring]Data JPA, Auditing적용 및 Auditing 직접 구현하기

0개의 댓글