[JPA] CascadeType.REMOVE vs orphanRemoval=true 차이점 알아보기 - 2편

🌱 들어가기 전

지난 포스팅에서는 CascadeType.REMOVE에 대해서 중점적으로 알아봤었는데, 이번에는 orphanRemoval=true 옵션에 대해서 한 번 알아보자. 엔티티 세팅은 지난 번과 거의 동일하기 때문에 변화가 생긴 부분에 대해서만 따로 짚도록 하겠다.

 

---

 

🌱 엔티티 수정하기

이번에는 CascadeType.REMOVE 대신에 orphanRemoval=true를 적용하자.

@Entity
class Concert(
    @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
    val id: Long = 0L,

    @Column(nullable = false)
    val name: String,

    @Column(nullable = false)
    val ticketLimit: Int,

    concertTickets: MutableList<ConcertTicket> = Collections.emptyList()
) {

    @OneToMany(
        fetch = FetchType.LAZY,
        mappedBy = "concert",
        cascade = [CascadeType.PERSIST],
        orphanRemoval = true // here!
    )
    val concertTickets: MutableList<ConcertTicket> = concertTickets.toMutableList()
}

 

---

 

🌱 orphanRemoval = true 

💬 부모 엔티티 제거하기 - 콘서트 엔티티 제거

@Test
@DisplayName("orphanRemoval=true 테스트 - 부모 엔티티 제거")
fun orphanRemoval_true_test_부모_엔티티_제거() {
    // given
    val 콘서트 = Concert(name = "인기 많은 콘서트", ticketLimit = 10)

    val 콘서트_티켓1 = ConcertTicket(userId = 1L, concert = 콘서트)
    val 콘서트_티켓2 = ConcertTicket(userId = 2L, concert = 콘서트)
    콘서트.addTicket(콘서트_티켓1)
    콘서트.addTicket(콘서트_티켓2)
    concertRepository.save(콘서트)

    val 저장된_콘서트들 = concertRepository.findAll()
    val 저장된_콘서트_티켓들 = concertTicketRepository.findAll()
    assertThat(저장된_콘서트들).hasSize(1)
    assertThat(저장된_콘서트_티켓들).hasSize(2)

    // when
    concertRepository.delete(콘서트)

    // then
    val 삭제_이후_저장된_콘서트들 = concertRepository.findAll()
    val 삭제_이후_저장된_콘서트_티켓들 = concertTicketRepository.findAll()

    assertThat(삭제_이후_저장된_콘서트들).hasSize(0)
    assertThat(삭제_이후_저장된_콘서트_티켓들).hasSize(0)
}

하나의 콘서트 엔티티에 대해 2개의 콘서트 티켓 엔티티가 존재하는 형태이다.

이때, 콘서트 엔티티를 제거하게 되면 CascadeType.REMOVE와 마찬가지로 부모와 연관된 자식 엔티티도 함께 제거되어 조회된 콘서트 티켓 엔티티의 개수가 0개인 것을 확인할 수 있다.

실제로 발생한 쿼리를 보더라도 콘서트 티켓 엔티티 2개에 대한 delete 쿼리와 콘서트 엔티티에 대한 1개의 delete 쿼리가 발생하여, 총 3개의 쿼리가 나간 것을 확인할 수 있다.

 

---

 

💬 부모 엔티티와 자식 엔티티 연관관계 끊기

@Test
@DisplayName("orphanRemoval=true 테스트 - 부모 엔티티에서 자식 엔티티 제거")
fun orphanRemoval_true_test_부모_엔티티에서_자식_엔티티_제거() {
    // given
    val 콘서트 = Concert(name = "인기 많은 콘서트", ticketLimit = 10)

    val 콘서트_티켓1 = ConcertTicket(userId = 1L, concert = 콘서트)
    val 콘서트_티켓2 = ConcertTicket(userId = 2L, concert = 콘서트)
    콘서트.addTicket(콘서트_티켓1)
    콘서트.addTicket(콘서트_티켓2)
    concertRepository.save(콘서트)

    val 저장된_콘서트들 = concertRepository.findAll()
    val 저장된_콘서트_티켓들 = concertTicketRepository.findAll()
    assertThat(저장된_콘서트들).hasSize(1)
    assertThat(저장된_콘서트_티켓들).hasSize(2)

    // when
    콘서트.concertTickets.remove(콘서트_티켓1)
    콘서트.concertTickets.remove(콘서트_티켓2)

    // then
    val 삭제_이후_저장된_콘서트들 = concertRepository.findAll()
    val 삭제_이후_저장된_콘서트_티켓들 = concertTicketRepository.findAll()

    assertThat(삭제_이후_저장된_콘서트들).hasSize(1) // here!
    assertThat(삭제_이후_저장된_콘서트_티켓들).hasSize(0)
}

이번에는 고아 객체를 만든 결과이다.

하지만, CascadeType.REMOVE와 다르게 단순히 콘서트 엔티티와 콘서트 티켓 엔티티 사이의 관계를 끊어주니 콘서트 티켓 엔티티가 실제 DB에서 제거된 것을 확인할 수 있다. 즉, 부모 엔티티와 자식 엔티티의 관계가 끊어지게 되면 고아(orphan)가 되고, 고아 객체에 대해 delete 쿼리(remove)가 발생하는 것이다.

실제로 발생한 쿼리를 확인하면 콘서트 티켓 엔티티 2개에 대한 delete 쿼리가 발생한 것을 볼 수 있다.

 

---

 

🌱 CascadeType.REMOVE + orphanRemoval = true 함께 사용하기

@Entity
class Concert(
    @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
    val id: Long = 0L,

    @Column(nullable = false)
    val name: String,

    @Column(nullable = false)
    val ticketLimit: Int,

    concertTickets: MutableList<ConcertTicket> = Collections.emptyList()
) {

    @OneToMany(
        fetch = FetchType.LAZY,
        mappedBy = "concert",
        cascade = [CascadeType.PERSIST, CascadeType.REMOVE],
        orphanRemoval = true
    )
    val concertTickets: MutableList<ConcertTicket> = concertTickets.toMutableList()
}

 

---

 

💬 부모 엔티티 제거하기 - 콘서트 엔티티 제거

@Test
@DisplayName("CascadeType.REMOVE + orphanRemoval=true 테스트 - 부모 엔티티 제거")
fun cascadeType_remove_orphanRemoval_true_test_부모_엔티티_제거() {
    // given
    val 콘서트 = Concert(name = "인기 많은 콘서트", ticketLimit = 10)

    val 콘서트_티켓1 = ConcertTicket(userId = 1L, concert = 콘서트)
    val 콘서트_티켓2 = ConcertTicket(userId = 2L, concert = 콘서트)
    콘서트.addTicket(콘서트_티켓1)
    콘서트.addTicket(콘서트_티켓2)
    concertRepository.save(콘서트)

    val 저장된_콘서트들 = concertRepository.findAll()
    val 저장된_콘서트_티켓들 = concertTicketRepository.findAll()
    assertThat(저장된_콘서트들).hasSize(1)
    assertThat(저장된_콘서트_티켓들).hasSize(2)

    // when
    concertRepository.delete(콘서트)

    // then
    val 삭제_이후_저장된_콘서트들 = concertRepository.findAll()
    val 삭제_이후_저장된_콘서트_티켓들 = concertTicketRepository.findAll()

    assertThat(삭제_이후_저장된_콘서트들).hasSize(0)
    assertThat(삭제_이후_저장된_콘서트_티켓들).hasSize(0)
}

CascadeType.REMOVE나 orphanRemoval = true 옵션 모두 부모 엔티티를 제거하면 연관된 자식 엔티티도 함께 제거되기 때문에 당연하게 두 옵션을 함께 사용하면 똑같이 제거되는 것을 볼 수 있다. 

 

---

 

💬 부모 엔티티와 자식 엔티티 연관관계 끊기

@Test
@DisplayName("CascadeType.REMOVE + orphanRemoval=true - 부모 엔티티에서 자식 엔티티 제거")
fun cascadeType_remove_orphanRemoval_true_test_부모_엔티티에서_자식_엔티티_제거() {
    // given
    val 콘서트 = Concert(name = "인기 많은 콘서트", ticketLimit = 10)

    val 콘서트_티켓1 = ConcertTicket(userId = 1L, concert = 콘서트)
    val 콘서트_티켓2 = ConcertTicket(userId = 2L, concert = 콘서트)
    콘서트.addTicket(콘서트_티켓1)
    콘서트.addTicket(콘서트_티켓2)
    concertRepository.save(콘서트)

    val 저장된_콘서트들 = concertRepository.findAll()
    val 저장된_콘서트_티켓들 = concertTicketRepository.findAll()
    assertThat(저장된_콘서트들).hasSize(1)
    assertThat(저장된_콘서트_티켓들).hasSize(2)

    // when
    콘서트.concertTickets.remove(콘서트_티켓1)
    콘서트.concertTickets.remove(콘서트_티켓2)

    // then
    val 삭제_이후_저장된_콘서트들 = concertRepository.findAll()
    val 삭제_이후_저장된_콘서트_티켓들 = concertTicketRepository.findAll()

    assertThat(삭제_이후_저장된_콘서트들).hasSize(1)
    assertThat(삭제_이후_저장된_콘서트_티켓들).hasSize(0)
}

같은 이유로 부모 엔티티와 자식 엔티티의 연관관계를 끊더라도 orphanRemoval = true 옵션에 의해서 제거되는 것을 확인할 수 있다.

 

---

 

🌱 orphanRemoval = true는 언제 사용을 지양하는 게 좋을까?

@Entity
class Concert(
    @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
    val id: Long = 0L,

    @Column(nullable = false)
    val name: String,

    @Column(nullable = false)
    val ticketLimit: Int,

    concertTickets: MutableList<ConcertTicket> = Collections.emptyList()
) {

    @OneToMany(
        fetch = FetchType.LAZY,
        mappedBy = "concert"
    )
    val concertTickets: MutableList<ConcertTicket> = concertTickets.toMutableList()
}

@Entity
class ConcertTicket(
    @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
    val id: Long = 0L,

    @Column(nullable = false)
    val userId: Long,

    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(
        name = "concert_id",
        foreignKey = ForeignKey(name = "fk_ticket_concert_id")
    )
    var concert: Concert
)

@Entity
class User(
    @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
    val id: Long = 0L,

    val name: String,

    concertTickets: MutableList<ConcertTicket> = Collections.emptyList()
) {

    @OneToMany(
        fetch = FetchType.LAZY,
        orphanRemoval = true
    )
    val concertTickets: MutableList<ConcertTicket> = concertTickets.toMutableList()
}

테스트를 위해서 사용자를 나타내는 'User' 엔티티를 만들고, 사용자 엔티티가 콘서트 티켓 엔티티를 자식으로 가지고 있는 상태로 만들었다. 즉, '콘서트 티켓 엔티티'에 대해서는 '콘서트'와 '사용자'라는 두 개의 부모 엔티티가 존재하는 형태인 것이다.

참고로, 콘서트 티켓 엔티티에 대해서는 사용자 엔티티에 대한 연관관계를 설정하지 않았다. (단방향) 또한, 기존 콘서트 엔티티의 CascadeType.PERSIST 옵션을 제거하고 사용자 엔티티가 가진 콘서트 티켓 엔티티에 대해서 orphanRemoval=true를 추가하였다.

 

@Test
@DisplayName("orphanRemoval=true - 다중 부모를 가지고 있는 경우, 하나의 부모 삭제")
fun orphanRemoval_true_multiple_parents_부모_엔티티_제거() {
    // given
    val 콘서트 = Concert(name = "인기 많은 콘서트", ticketLimit = 10)

    val 콘서트_티켓1 = ConcertTicket(userId = 1L, concert = 콘서트)
    val 콘서트_티켓2 = ConcertTicket(userId = 2L, concert = 콘서트)
    concertRepository.save(콘서트)
    concertTicketRepository.saveAll(listOf(콘서트_티켓1, 콘서트_티켓2))

    val 사용자 = User(name = "져니")
    userRepository.save(사용자)

    // when
    userRepository.delete(사용자)

    // then
    val 삭제_이후_저장된_콘서트들 = concertRepository.findAll()
    val 삭제_이후_저장된_콘서트_티켓들 = concertTicketRepository.findAll()
    val 모든_사용자들 = userRepository.findAll()

    assertThat(삭제_이후_저장된_콘서트들).hasSize(1)
    assertThat(삭제_이후_저장된_콘서트_티켓들).hasSize(2)
    assertThat(모든_사용자들).hasSize(0)
}

우선, PERSIST 없이 여러 부모가 있을 때 하나의 부모에 대해서 제거를 하게 되면 단순히 사용자에 대한 delete 쿼리만 발생한다.

 

@Entity
class User(
    @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
    val id: Long = 0L,

    val name: String,

    concertTickets: List<ConcertTicket> = Collections.emptyList()
) {

    @OneToMany(
        fetch = FetchType.LAZY,
        cascade = [CascadeType.PERSIST],
        orphanRemoval = true
    )
    val concertTickets: MutableList<ConcertTicket> = concertTickets.toMutableList()
}

하지만, 사용자와 콘서트 엔티티에 대해서 cascade 옵션을 통해 PERSIST를 준다면 결과가 달라지게 된다.

 

---

 

💬 부모 엔티티 제거하기 - 사용자 엔티티 제거 (다중 부모)

@Test
@DisplayName("orphanRemoval=true - 다중 부모를 가지고 있는 경우, 하나의 부모 삭제")
fun orphanRemoval_true_multiple_parents_부모_엔티티_제거() {
    // given
    val 콘서트 = Concert(name = "인기 많은 콘서트", ticketLimit = 10)

    val 콘서트_티켓1 = ConcertTicket(userId = 1L, concert = 콘서트)
    val 콘서트_티켓2 = ConcertTicket(userId = 2L, concert = 콘서트)
    concertRepository.save(콘서트)

    val 사용자 = User(name = "져니", concertTickets = mutableListOf(콘서트_티켓1, 콘서트_티켓2))
    userRepository.save(사용자)

    // when
    userRepository.delete(사용자)

    // then
    val 삭제_이후_저장된_콘서트들 = concertRepository.findAll()
    val 삭제_이후_저장된_콘서트_티켓들 = concertTicketRepository.findAll()
    val 모든_사용자들 = userRepository.findAll()

    assertThat(삭제_이후_저장된_콘서트들).hasSize(1)
    assertThat(삭제_이후_저장된_콘서트_티켓들).hasSize(0)
    assertThat(모든_사용자들).hasSize(0)
}

하지만, 사용자를 저장할 때 콘서트 티켓을 함께 저장하고 (PERSIST에 의해서 영속화 -> insert) 사용자 엔티티를 제거하게 되면 영속화된 콘서트 티켓 엔티티도 함께 제거된다. 즉, ⭐️ 가장 큰 포인트는 영속화를 통해서 부모와 자식의 생명주기를 동일하게 만드는 것이다.

 

만약 사용자에 대한 정보만 제거하고 싶고 콘서트 티켓에 대해서는 제거하고 싶지 않은 상황이 발생한다면 (물론, 이런 상황은 거의 없을 것이다. 대부분 자식의 생명주기는 부모에게 종속되는 것이 일반적이니까) orphanRemoval = true의 사용을 잘 고민해봐야 한다. 

---

 

💬 부모 엔티티와 자식 엔티티 연관관계 끊기

@Test
@DisplayName("orphanRemoval=true - 다중 부모를 가지고 있는 경우, 하나의 부모에서 자식 엔티티 제거")
fun orphanRemoval_true_multiple_parents_부모에서_자식_엔티티_제거() {
    // given
    val 콘서트 = Concert(name = "인기 많은 콘서트", ticketLimit = 10)
    concertRepository.save(콘서트)

    val 콘서트_티켓1 = ConcertTicket(userId = 1L, concert = 콘서트)
    val 콘서트_티켓2 = ConcertTicket(userId = 2L, concert = 콘서트)
    val 사용자 = User(name = "져니", concertTickets = mutableListOf(콘서트_티켓1, 콘서트_티켓2))
    userRepository.save(사용자)

    // when
    사용자.concertTickets.remove(콘서트_티켓1)
    사용자.concertTickets.remove(콘서트_티켓2)

    // then
    val 삭제_이후_저장된_콘서트들 = concertRepository.findAll()
    val 삭제_이후_저장된_콘서트_티켓들 = concertTicketRepository.findAll()
    val 모든_사용자들 = userRepository.findAll()

    assertThat(삭제_이후_저장된_콘서트들).hasSize(1)
    assertThat(삭제_이후_저장된_콘서트_티켓들).hasSize(0)
    assertThat(모든_사용자들[0].concertTickets).hasSize(0)
}

이번에는 영속성 전이 옵션을 설정한 부모 엔티티 (사용자)에서 자식 엔티티 (콘서트 티켓)에 대한 연관관계를 끊어보자. 콘서트 티켓 엔티티는 DB 상으로 콘서트와 연관관계가 있음에도 영속성 전이 옵션이 설정되어 있는 사용자와 콘서트 티켓 사이의 연관관계가 끊어지니 제거되는 것을 볼 수 있다. 

 

---

 

🌱 결론

- 영속성 전이 옵션을(PERSIST) 통해서 부모와 자식의 생명주기가 맞춰져 있어야 한다.

 

CascadeType.REMOVE

@OneToMany

- 부모 엔티티 제거 시 부모와 자식 모두 실제 DB에서 제거된다.

- 부모 엔티티와 자식 엔티티의 연관관계가 끊어지더라도 실제 DB에서 제거되지 않는다.

 

@ManyToOne
- 부모 / 자식 엔티티 제거 시 연관된 부모, 자식 모두 실제 DB에서 제거된다.
- 이때, 자식 엔티티가 여러 개일 경우 외래키 제약 조건 위반으로 인해 예외가 발생할 수 있다.
- 부모 엔티티와 자식 엔티티의 연관관계가 끊어지더라도 실제 DB에서 제거되지 않는다.

orphanRemoval = true

- 부모 엔티티 제거 시 부모와 자식 모두 실제 DB에서 제거된다.
- 부모 엔티티와 자식 엔티티의 연관관계가 끊어지면 자식은 실제 DB에서 제거된다.