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

🌱 들어가기 전

JPA를 공부하면서 CascadeType.REMOVE와 orphanRemoval = true 옵션에 대해서 어떤 차이가 있는지 제대로 인지한 적이 없는 것 같아서, 이번에 공부할 겸 여러 가지 테스트를 진행해보며 두 옵션의 차이를 공부해보았다.

결과적으로 말하자면 Cascade 옵션은 부모 엔티티와 자식 엔티티의 영속 상태를 관리하는 것이고, orphanRemoval은 조금 더 세부적으로 고아 객체에 대한 관리라는 생각이 들었다. 지금부터 여러 케스트를 테스트하며 하나씩 알아보자.

 

---

 

🌱 엔티티 세팅하기

1:N 관계를 담당해줄 '콘서트' 엔티티와 '콘서트 티켓' 엔티티를 생성하였다.

둘 사이의 관계는 양방향으로 설정하였으며, 하나의 콘서트는 여러 개의 콘서트 티켓을 보유할 수 있도록 설계하였다.

 

<Concert>

@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()

    fun addTicket(concertTicket: ConcertTicket) {
        concertTickets.add(concertTicket)
    }
}

 

<ConcertTicket>

@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
)

콘서트 엔티티는 콘서트 티켓 엔티티를 추가할 수 있으며, 학습을 위해 외래키 제약 조건을 설정하였다.

 

---

 

🌱 테스트 환경 세팅하기

<application-test.yml>

spring:
  datasource:
    driver-class-name: org.h2.Driver
    url: jdbc:h2:mem:testdb;MODE=MySQL

  jpa:
    hibernate:
      ddl-auto: create-drop
    properties:
      hibernate:
        globally_quoted_identifiers: true
        format_sql: true
    show-sql: true

테스트 환경 세팅을 위해 application-test.yml 파일을 생성하였다.

이때 show-sql 옵션을 통해서 JPA에서 어떤 쿼리가 발생하는지 확인하자.

 

@DataJpaTest
@ActiveProfiles("test")
@TestConstructor(autowireMode = TestConstructor.AutowireMode.ALL)
class ConcertTest(
    private val concertRepository: ConcertRepository,
    private val concertTicketRepository: ConcertTicketRepository
) {
}

테스트에서 사용한 뼈대 코드이다.

@DataJpaTest를 통해서 JPA 환경을 테스트할 수 있도록 만들었으며, 활성 프로파일은 test로 주어서 application-test.yml의 정보를 읽을 수 있도록 만들었다. 또한, 생성자에서 바로 주입받을 수 있도록 autowireMode를 TestConstructor.AutowireMode.ALL로 설정하였다.

 

---

 

🌱 @OneToMany에서 CascadeType.REMOVE 

@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.REMOVE, CascadeType.PERSIST] // Here!
    )
    val concertTickets: MutableList<ConcertTicket> = concertTickets.toMutableList()

테스트를 위해서 콘서트 티켓 엔티티에 대해서 CascadeType.REMOVE를 설정해주었다.

이때, 부모 엔티티 저장 시 자식 엔티티도 함께 저장되도록 만들기 위해서 CascadeType.PERSIST로 설정해주었다.

 

---

 

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

@Test
@DisplayName("@OneToMany: CascadeType.REMOVE 테스트 - 부모 엔티티 제거")
fun oneToMany_cascadeType_REMOVE_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개의 콘서트 티켓을 발급받고, 저장 직후 findAll을 통해 잘 저장되었는지 확인했다.

이후, 부모 엔티티인 '콘서트 엔티티'를 제거한 다음 조회를 해보면 콘서트 엔티티와 콘서트 티켓 엔티티 모두가 제거된 것을 확인할 수 있다.

실제로 발생한 쿼리를 확인해보면 콘서트 티켓 엔티티를 제거하기 위한 delete 쿼리가 2번, 콘서트 엔티티를 제거하기 위한 delete 쿼리가 1번 발생하여 총 3번의 쿼리가 나간 것을 볼 수 있다.

 

---

 

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

@Test
@DisplayName("@OneToMany: CascadeType.REMOVE 테스트 - 부모 엔티티에서 자식 엔티티 제거")
fun oneToMany_cascadeType_REMOVE_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(2)
}

부모 엔티티인 콘서트 엔티티를 조회한 후, 해당 엔티티와 관련된 콘서트 티켓 엔티티에 대해 remove를 진행하여 부모와 자식간의 연관관계를 끊어주었다. 이때 콘서트 티켓 엔티티 2개는 '고아 객체'가 되었다고 판단하는데, CascadeType.REMOVE에서는 고아 객체가 발생하더라도 실제 DB에서 제거되지는 않는다.

 

---

 

🌱 @ManyToOne에서 CascadeType.REMOVE 

cascadeType의 경우 @OneToMany뿐만 아니라 @ManyToOne에서도 지정할 수 있다.

@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] // here!
    )
    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,
        cascade = [CascadeType.REMOVE]
    )
    @JoinColumn(
        name = "concert_id",
        foreignKey = ForeignKey(name = "fk_ticket_concert_id")
    )
    var concert: Concert
)

기존 콘서트 엔티티에 적용하였던 CascadeType.REMOVE를 제거하고, 콘서트 티켓 엔티티에 대해서 적용하였다.

 

---

 

💬 자식 엔티티 제거하기 - 콘서트 티켓 엔티티 제거

@Test
@DisplayName("@ManyToOne: CascadeType.REMOVE 테스트 - 자식 엔티티 제거")
fun manyToOne_cascadeType_REMOVE_test_자식_엔티티_제거() {
    // given
    val 콘서트 = Concert(name = "인기 많은 콘서트", ticketLimit = 10)
    val 콘서트_티켓1 = ConcertTicket(userId = 1L, concert = 콘서트)
    콘서트.addTicket(콘서트_티켓1)
    concertRepository.save(콘서트)

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

    // when
    concertTicketRepository.delete(콘서트_티켓1);

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

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

위 테스트의 경우, 콘서트 엔티티에 한 개의 콘서트 티켓 엔티티가 있는 경우이다. (자식이 1개만 있는 경우)

이때 자식 엔티티를 제거하게 된다면 해당 자식 엔티티와 연관된 부모 엔티티와 자식 엔티티 모두가 제거된다.

- 참고로, 여기서 연관이 되어 있다는 것은 단순히 'DB에서 FK로 연결이 되어 있다'라는 의미보다, 영속화가 되어 있는지를 확인한다. 영속화되지 않고 단순히 FK로만 연결이 되어 있다면 콘서트 티켓 엔티티를 제거하더라도 콘서트 엔티티까지 제거되지는 않는다.

 

그렇다면, 여러 개의 자식이 있을 때는 어떻게 될까?

@Test
@DisplayName("@ManyToOne: CascadeType.REMOVE 테스트 - 자식 엔티티 제거 : 자식이 여러 개일 경우")
fun manyToOne_cascadeType_REMOVE_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
    concertTicketRepository.delete(콘서트_티켓1)

    // then
    assertThatThrownBy {
        concertRepository.findAll()
		// concertTicketRepository.findAll()
    }.isInstanceOf(DataIntegrityViolationException::class.java)
}

콘서트 엔티티에 2개의 콘서트 티켓 엔티티가 있고, 첫 번째 콘서트 티켓 엔티티에 대해서 제거한 상황이다.

이때, 콘서트에 대해 조회하는 시점에서 DataIntegrityViolationException이 발생한다.

- 참고로, 주석으로 concertTicketRepository.findAll()을 해두었는데, 콘서트든 콘서트 티켓 엔티티든 조회하는 쿼리를 발생시킬 때 오류가 발생하기 때문이다.

 

위의 테스트 코드를 돌리는 가장 처음 시점인 엔티티 저장 때 DB 상황은 아래와 같을 것이다.

 

[concert]

id	name	ticket_limit
1	인기 많은 콘서트	10

 

[concert_ticket]

id	user_id	concert_id
1	1	1
2	2	1

 

PK = 1인 콘서트 레코드가 저장되어 있고, 해당 레코드를 FK로 가지고 있는 PK = 1, 2인 콘서트 티켓 레코드가 저장되어 있는 형태이다.

 

하지만, 실제 생성된 쿼리를 보면 1개의 콘서트 티켓에 대해 제거하고, 바로 콘서트를 제거하는 쿼리가 발생한다. 

concert_ticket 테이블의 PK=1인 첫 번째 레코드가 제거되고, concert 테이블의 PK=1인 첫 번째 레코드가 제거되는 상황이다. 하지만, concert 테이블의 레코드가 제거되려고 할 때 엔티티에 걸어두었던 외래키 제약 조건에 의해서 오류가 발생하게 된다.

@Entity
class ConcertTicket(
    ....
    @JoinColumn(
        name = "concert_id",
        foreignKey = ForeignKey(name = "fk_ticket_concert_id") // here
    )
    var concert: Concert
)

때문에 concert 테이블의 PK=1인 레코드를 제거하면, concert_ticket 테이블의 두 번째 레코드가 참조하고 있기 때문에 fk 값이 null이 될 수 없어 오류가 발생하는 것이다.

 

⭐️ 왜 delete하는 시점이 아닌, findAll()을 통해 조회하는 시점에 오류가 발생하는 걸까?

@Test
@DisplayName("@ManyToOne: CascadeType.REMOVE 테스트 - 자식 엔티티 제거 : 자식이 여러 개일 경우")
fun manyToOne_cascadeType_REMOVE_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
    assertDoesNotThrow {
        concertTicketRepository.delete(콘서트_티켓1)
    }
}

실제로, 단순히 콘서트 티켓 레파지토리에서 delete를 한다고 해서 오류가 발생하는 것은 아니다.

애초에 조회하기 전까지 delete 쿼리가 발생하지도 않는다. (위의 select는 콘서트, 콘서트 티켓에 대한 findAll())

JPA의 영속성 컨텍스트를 생각하면 간단하게 답이 나올 것이다.

 

delete의 경우 실제 DB로 제거를 위한 쿼리를 발생시키는 것이 아닌, 단순히 '영속성 컨텍스트'에서 해당 엔티티를 '제거 처리'를 하는 것이기 때문이다.

@Override
@Transactional
@SuppressWarnings("unchecked")
public void delete(T entity) {

	Assert.notNull(entity, "Entity must not be null");

	if (entityInformation.isNew(entity)) {
		return;
	}

	Class<?> type = ProxyUtils.getUserClass(entity);

	T existing = (T) em.find(type, entityInformation.getId(entity));

	// if the entity to be deleted doesn't exist, delete is a NOOP
	if (existing == null) {
		return;
	}

	em.remove(em.contains(entity) ? entity : em.merge(entity));
}

실제로, 구현체를 슬쩍 보면 em.remove()를 통해서 entityManager에 존재하는 엔티티에 대해서 제거하는 것을 볼 수 있다.

 

그래서, 실제 DB에 제거 쿼리를 발생시키고 싶다면 아래와 같이 테스트를 수정해야 한다.

fun manyToOne_cascadeType_REMOVE_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
    assertDoesNotThrow {
        concertTicketRepository.delete(콘서트_티켓1)
    }

    assertThatThrownBy {
        entityManager.flush()
    }.isInstanceOf(ConstraintViolationException::class.java)
}

entityManager에 대해 강제로 플러시를 해서, 영속성 컨텍스트의 내용을 DB에 반영시키는 것이다.

이렇게 되면 아까와 다르게 별도의 조회 쿼리를 발생시키지 않더라도 delete 쿼리가 발생한다. 다만, 외래키 제약 조건이 발생하기 때문에 똑같이 ConstraintViolationException은 생길 수밖에 없다.

💡 DataIntegrityViolationException와 ConstraintViolationException은 모두 외래키 제약 조건 위반에 의해서 발생한다. 다만, ConstraintViolationException의 경우 스프링 프레임워크에서 제공하는 예외 클래스이고, ConstraintViolationException는 하이버네이트에서 제공하는 예외 클래스이다.

 

---

 

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

@Test
@DisplayName("@ManyToOne: CascadeType.REMOVE 테스트 - 부모 엔티티에서 자식 엔티티 제거")
fun manyToOne_cascadeType_REMOVE_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(2)
}

이전의 @OneToMany의 경우, 부모 엔티티에서 자식 엔티티를 제거하더라도 아무 일도 발생하지 않았었다.

마찬가지로 @ManyToOne의 역시 고아 객체가 발생하더라도 실제 DB에 delete 쿼리가 발생하지 않아서 그대로 조회가 되는 것을 확인할 수 있다.

 

---

 

생각보다 글이 길어져서 orphanRemoval에 대한 내용은 2편에서 알아보도록 하자!