영속성 전이 CASCADE

저번에 잠깐 알아보긴 했는데 오늘 포스팅하는김에 한개 더 남기자

영속성 전이

특정 엔티티를 영속 상태로 만들 때 연관된 엔티티도 함께 영속 상태로 만들고 싶다면 영속성 전이 기능을 사용하면 된다.
JPA의 CASCADE옵션으로 영속성 전이를 제공한다. 쉽게 말해서 영속성 전이를 사용하면 부모 엔티티를 저장할 때 자식 엔티티도 함께 저장할 수 있다.

@Entity
@Data
public class Parent {

  @Id @GeneratedValue
  private Long id;

  @OneToMany(mappedBy = "parent")
  private List<Child> children = new ArrayList<>();
}

@Entity
@Data
public class Child {

  @Id @GeneratedValue
  private Long ig;

  @ManyToOne
  private Parent parent;
}

이런 엔티티가 있다고 가장하자. 1대N의 구조인 부모와 자식관계를 나타내고 있다.
만약 1명의 부모와 2명의 자식을 저장한다고 가정할때 아래 코드와 같이 작성할 것이다.

private static void saveNoCascade(EntityManager entityManager){
  Parent parent = new Parent();
  entityManager.persist(parent);

  Child child1 = new Child();
  child1.setParent(parent);
  entityManager.persist(child1);

  Child child2 = new Child();
  child2.setParent(parent);
  entityManager.persist(child2);
}

JPA에서 엔티티를 저장할 때 연관된 엔티티는 모두 영속 상태이어야 한다. 따라서 부모 엔티티를 영속 상태로 만들고 나머지 두개의 자식들도 영속 상태로 만들었다.

영속성 전이 (저장)

@Entity
@Data
public class Parent {

  @Id @GeneratedValue
  private Long id;

  @OneToMany(mappedBy = "parent" ,cascade = CascadeType.PERSIST)
  private List<Child> children = new ArrayList<>();
}

위와 같이 cascade = CascadeType.PERSIST 로 지정하면 부모를 영속화할 때 연관된 자식들도 함께 영속화 한다.

private static void saveWithCascade(EntityManager entityManager){
  Child child1 = new Child();
  Child child2 = new Child();

  Parent parent = new Parent();
  child1.setParent(parent);
  child2.setParent(parent);

  parent.getChildren().add(child1);
  parent.getChildren().add(child2);

  entityManager.persist(parent);
}

부모 엔티티만 영속화를 했지만 CascadeType.PERSIST 같은 속성으로 자식 엔티티까지 함께 영속화해서 저장한다.

영속성 전이 (삭제)

부모와 자식 엔티티를 모두 제거하려면 아래와 같이 각각 엔티티를 한개씩 삭제해야 한다.

private static void deleteNoCascade(EntityManager entityManager){
  Parent parent = entityManager.find(Parent.class, 1L);
  Child child1 = entityManager.find(Child.class, 2L);
  Child child2 = entityManager.find(Child.class, 3L);

  entityManager.remove(child1);
  entityManager.remove(child2);
  entityManager.remove(parent);
}

영속성 전이 CascadeType.REMOVE를 사용하면 부모 엔티티와 연관된 자식 엔티티도 함께 삭제 된다.

@OneToMany(mappedBy = "parent" ,cascade = CascadeType.REMOVE)
private List<Child> children = new ArrayList<>();
private static void deleteWithCascade(EntityManager entityManager){
  Parent parent = entityManager.find(Parent.class, 1L);
  entityManager.remove(parent);
}

코드를 실행하면 DELETE SQL을 3번 실행하고 부모는 물론 연관된 자식도 모두 삭제한다. 삭제 순서를 외래키를 고려해서 자식부터 삭제하고 부모를 삭제한다. 만약 CascadeType.REMOVE를 설정 하지 않고 하면 어떻게 될까?
부모 엔티티만 삭제 하려다 외래키 제약 조건으로 인해 예외가 발생한다.

java.lang.IllegalArgumentException: attempt to create delete event with null entity

이외에도 CascadeType 속성은 여러가지가 있다 CascadeType enum을 통해 확인

고아 객체

JPA는 부모 엔티티와 연관관계가 끊어진 자식 엔티티를 자동으로 삭제하는 기능을 제공하는데 이것을 고아 객체 제거라 한다. 이 기능을 사용해서 부모 엔티티의 컬렉션에서 자식 엔티티의 참조만 제거하면 자식 엔티티가 자동으로 삭제 된다.

@OneToMany(mappedBy = "parent", orphanRemoval = true)
private List<Child> children = new ArrayList<>();
private static void deleteOrphan(EntityManager entityManager){
  Parent parent = entityManager.find(Parent.class, 1L);
  parent.getChildren().remove(0);
}

이렇게 하면 컬렉션에서 첫번째 자식을 삭제한다고 되어있는데 나는 왜 안되지? orphanRemoval = true 을 주면 데이터베이스에서도 삭제가 된다고 하는데..
만약 모두 비우고 싶다면 clear() 메서드를 사용하면 된다. orphanRemoval 옵션은 @OneToOne 또는 @OneToMany에서만 사용할 수 있다.

영속성 전이 + 고아 객체

orphanRemoval = true 와 CascadeType.ALL을 동시에 사용하면 어떻게 될까? 일반적으로 엔티티는 entityManager.persist() 통해 영속화 되고 entityManager.remove() 를 통해 제거 된다. 이것은 엔티티 스스로 생명주기를 관리한다는 뜻이다. 그런데 두 옵션을 모두 활성화하면 부모 엔티티를 통해서 자식의 생명주기까지 관리할 수 있다.
자식을 저장하려면 부모에 등록만 하면 된다. (CASCADE)

Parent parent = entityManager.find(Parent.class, parentId);
parent.addChild(child1);

자식을 삭제하려면 부모에서 제거하면 된다.

Parent parent = entityManager.find(Parent.class, parentId);
parent.getChildren().remove(child1);

근데 왜 나는 orphanRemoval = true 이게 안먹힐까?

JPA 영속성

오늘 알아볼 것은 JPA의 기초인 영속성을 알아보자. 맨날 매핑, 조인등등 알아봤지만 JPA에서 가장 중요한 영속성을 포스팅은 안한듯하다.

영속성 컨텍스트

영속성 컨텍스트란 엔티티를 영구 저장하는 환경? 이라고 해석 할 수 있다. 엔티티 매니저로 엔티티를 저장하거나 조회하면 엔티티 매니저는 영속성 컨텍스트에 엔티티를 보관하고 관리한다.

entityManager.persist(member)

이 코드는 단순히 회원 엔티티를 저장하는데 정확히 이야기 하면 persist() 메서드는 엔티티 매니저를 사용해서 회원 엔티티를 영속성 컨텍스트에 저장한다.

엔티티의 생명주기

  • 비영속성(new/transient) : 영속성 컨텍스트와 전혀 관계가 없는 상태
  • 영속(managed) : 영속성 컨텍스트에 저장된 상태
  • 준영속(detached) : 영속성 컨텍스트에 저장되었다가 분리된 상태
  • 삭제(removed) : 삭제된 상태

한개씩 살펴보자

비영속성

엔티티 객체를 생성하고 순수한 객체 상태이며 저장하지 않았다. 영속성 컨텍스트나 데이터베이스와는 전혀 관련이 없다. 이것을 비영속성 상태라 한다.

Member member = new Member();
member.setId("MemberId1");
member.setName("name1");

영속

엔티티 매니저를 통해서 엔티티를 영속성 컨텍스트에 저장했다. 영속성 컨텍스트가 관리하는 엔티티를 영속 상태라 한다. 이제 회원 엔티티는 비영속상태에서 영속상태가 되었다. 결국 영속 상태라는 것은 영속성 컨텍스트에 의해 관리된다는 뜻이다. 그리고 entityManager.find()나 JPQL을 사용해서 조회한 엔티티도 영속성 컨텍스트가 관리하는 영속상태이다.

entityManager.persist(member);

준영속

영속성 컨텍스트가 관리하던 영속 상태의 엔티티를 영속성 컨텍스트가 관리하지 않으면 준영속 상태가 된다. 특정 엔티티를 준영속 상태로 만들려면 entityManager.detach()를 호출하면 된다. entityManager.close()를 호출해서 영속성 컨텍스트를 닫거나 entityManager.clear()를 호출해서 영속성 컨텍스트를 초기화해도 영속성 컨텍스트가 관리하던 영속 상태의 엔티티는 준영속이 된다.

entityManager.detach(member);

삭제

엔티티를 영속성 컨텍스트와 데이터베이스에서 삭제한다.

entityManager.remove(member);

특징

  1. 영속성 컨텍스트는 엔티티를 식별자 값으로 구분한다. 따라서 영속 상태는 식별자 값이 반드시 있어야 한다. 없으면 예외가 발생한다.
  2. 영속성 컨텍스트에 엔티티를 저장하면 이 엔티티는 언제 저장이 될까? JPA는 보통 트랜잭션을 커밋하는 순간 영속성 컨텍스트에 새로 저장된 엔티티를 데이터베이스에 반영하는데 이를 플러시(flush)라 한다.
  3. 영속성 컨텍스트가 엔티티를 관리하면 다음과 같은 장점이 있다.
    • 1차 캐시
    • 동일성 보장
    • 트랜잭션을 지원하는 쓰기 지연
    • 변경 감지
    • 지연 로딩

플러시

플러시(flush())는 영속성 컨텍스트의 변경 내용을 데이터베이스에 반영한다. 플러시를 실행하면 다음과 같은 일이 일어난다.
1. 변경 감지가 동작해서 영속성 컨텍스트에 있는 모든 엔티티를 스냅샷과 비교해서 수정된 엔티티를 찾는다. 수정된 엔티티는 수정 쿼리를 만들어 쓰기 지연 SQL 저장소에 등록한다.
2. 쓰기 지연 SQL 저장소의 쿼리를 데이터베이스에 전송한다. (등록, 수정, 삭제 쿼리)

영속성 컨텍스트를 플러시하는 방법은 3가지가 있다.
1. 직접 호출 하는 방법인데 엔티티 매니저의 flush() 메서드를 직접 호출해서 영속성 컨텍스트를 강제로 플러시 하면 도니다. 테스트나 다른 프레임워크와 JPA를 함께 사용할 때를 제외하고 거의 사용하지 않는다.
2. 트랜잭션 커밋이 자동으로 플러시가 호출된다.
3. JPQL 쿼리 실행 할때에도 플러시가 자동으로 호출된다.

준영속

영속상태에서 준영속 상태 변화를 알아보자
위에서도 말했듯이 영속성 컨텍스트가 관리하는 영속 상태의 엔티티가 영속성 컨텍스트에서 분리된 것을 준영속 상태라 한다. 준영속 상태의 엔티티는 영속성 컨텍스트가 제공하는 기능을 사용할 수 없다.
영속 상태의 엔티티를 준영속 상태로 만드는 방법은 크게 3가지가 있다.
1. entityManager.detach(member) // 특정 엔티티만 준영속 상태로 전환한다.
2. entityManager.clear() // 영속성 컨텍스트를 완전히 초기화 한다.
3. entityManager.close() // 영속성 컨텍스트를 종료한다.

private static void detached(EntityManager entityManager) {
    Member member3 = new Member("Id3", "회원A", 40);
    entityManager.persist(member3);
    entityManager.detach(member3); // 준영속으로 전환
//    entityManager.clear();   //모든 엔티티를 준영속 전환
//    entityManager.close(); // 영속성 컨텍스트 종료
}

detach 메서드를 호출하는 순간 해당 엔티티를 관리하지 말라는 것이다. 이는 1차 캐시부터 쓰기 지연 SQL 저장소까지 해당 엔티티를 관리하기 위한 모든 정보가 사라진다. 실제 위의 코드도 데이터베이스에 저장되지 않는다.
detach 메서드는 엔티티 하나의 대상이지만 clear는 모든 엔티티를 초기화해서 준영속 상태로 만든다. 이때에도 마찬가지로 데이터베이스에 반영되지 않는다.
close 메서드도 clear랑 비슷하지만 약간 다른것 같다 close는 entityManager를 종료 시키기에 다시 entityManager를 만들어야 하는 듯하다.

준영속 상태의 특징

  1. 거의 비영속 상태에 가깝다.
  2. 비영속과는 달리 식별자 값을 가지고 있다.
  3. 지연 로딩을 할 수 없다.

병합

준영속 상태의 엔티티를 다시 영속 상태로 변경하려면 병합을 사용하면 된다. merge() 메서드는 준영속 상태의 엔티티를 받아서 새로운 영속상태의 엔티티를 반환한다.

Member member = createMember("id4", "회원B", 31);
//준영속일때 변경
member.setUsername("병합");
merge(member);
print();

private static Member createMember(String id, String name, Integer age) {
    EntityManager entityManager = entityManagerFactory.createEntityManager();
    EntityTransaction transaction = entityManager.getTransaction();

    Member member = new Member(id, name, age);
    try {
        transaction.begin(); // 트랜잭션 시작
        entityManager.persist(member);
        transaction.commit();
    } catch (Exception e) {
        transaction.rollback();
    } finally {
        entityManager.close();
    }
    return member;
}

private static void merge(Member member) {
    EntityManager entityManager = entityManagerFactory.createEntityManager();
    EntityTransaction transaction = entityManager.getTransaction();
    try {
        transaction.begin(); // 트랜잭션 시작
        Member mergeMember = entityManager.merge(member);
        System.out.println("entityManager.contains(mergeMember) : " +
                entityManager.contains(mergeMember)
        );
        System.out.println("entityManager.contains(member) : " +
                entityManager.contains(member));
        transaction.commit();
    } catch (Exception e) {
        transaction.rollback();
    } finally {
        entityManager.close();
    }
}

만약 위와 같은 코드가 있다면 준영속일때 변경을 했지만 merge를 해서 다시 영속 상태로 변경시켰다. 그럼 실제 데이터베이스에도 준영속 상태에서 변경된 값이 들어간다.

비영속 병합

병합은 비영속 엔티티도 영속 상태로 만들 수 있다.

Member member = new Member();
Member newMember = entityManager.merge(member);
tx.commit();

병합은 파라미터로 넘어온 엔티티의 식별자 값으로 영속성 컨텍스트를 조회하고 찾는 엔티티가 없으면 데이터베이스에서 조회한다. 만약 데이터베이스에서도 찾지 못하면 새로운 엔티티를 생성해서 병합한다. 병합은 준영속, 비영속을 신경쓰지 않는다. 식별자 값으로 엔티티를 조회할 수 있으면 불러서 병합하고 조회할 수 없으면 새로 생성해서 병합한다. 따라서 병합은 save or update 기능을 수행한다.

이것으로 JPA 영속성에 대해서 알아봤다.

JPA 부가 기능

@OrderBy

@OrderColumn이 데이터베이스에 순서용 컬럼을 매핑해서 관리했다면 @OrderBy는 데이터베이스의 Order by절을 사용해서 컬렉션을 정렬한다. 따라서 순서용 컬럼을 매핑하지 않아도 된다. 그리고 @OrderBy는 모든 컬렉션에 사용할 수 있다.

@OneToMany(mappedBy = "team")
@OrderBy("username desc, id asc")
private Set<Member> members = new HashSet<Member>();

위는 Team.members를 보면 @OrderBy를 적용했다. 그리고 값으로는 username desc, id asc를 사용해서 username필드로 내림차순 id로는 오름차순 정렬을 하였다. @OrderBy의 값은 JPQL의 order by절처럼 엔티티의 필드를 대상으로 한다.

select m.*
from
   Member m
where
   m.team_id = ?
order by
   m.member_name desc,
   m.id asc

참고로 하이버네이트는 Set에 OrderBy를 적용해서 결과를 조회하면 순서를 유지하기 위해 HashSet대신 LinkedHashSet을 내부에서 사용한다.

@Converter

컨버터를 사용하면 엔티티의 데이터를 변환해서 데이터베이스에 저장할 수 있다. 예를들어 회원 VIP여부를 자바의 boolean 타입을 사용하고 싶다고 가정 할 때 JPA를 사용하면 자바의 boolean 타입은 방언에 따라 다르지만 데이터베이스에 저장될 때 0 또는 1인 숫자로 저장된다. 그런데 데이터베이스에 숫자 대신 문자 Y 또는 N으로 저장하고 싶다면 컨버터를 이용하면 된다.

@Entity
@Data
public class Member {

  @Id
  private String id;

  private String name;

  @Convert(converter = BooleanToYNConverter.class)
  private boolean vip;
}

회원 엔티티의 vip 필드는 boolean 타입이다. @Convert를 적용해서 데이터베이스에 저장되기 직전에 BooleanToYNConverter 컨버터가 동작하도록 했다.

@Converter
public class BooleanToYNConverter implements AttributeConverter<Boolean, String> {

  public String convertToDatabaseColumn(Boolean attribute) {
    return (attribute != null && attribute) ? "Y" : "N";
  }

  public Boolean convertToEntityAttribute(String s) {
    return "Y".equals(s);
  }
}

컨버터 클래스는 @Converter 어노테이션을 사용하고 AttributeConverter 인터페이스를 구현해야 한다. 현재 우리는 Boolean타입을 String 타입으로 변환했다.
AttributeConverter 인터페이스는 두개의 메서드가 존재 한다.

convertToDatabaseColumn() : 엔티티의 데이터를 데이터베이스 컬럼에 저장할 데이터로 변환한다. 위에서는 true이면 Y 아니면 false면 N을 반환하도록 했다.
convertToEntityAttribute() : 데이터베이스에서 조회한 컬럼 데이터를 엔티티의 데이터로 변환한다. 위에서는 Y면 true아니면 false를 반환했다.

컨버터 클래스 레벨로 가능하다.

@Entity
@Data
@Convert(converter = BooleanToYNConverter.class, attributeName = "vip")
public class Member {

  @Id
  private String id;

  private String name;

  private boolean vip;
}

글로벌하게 설정도 가능하다.

@Converter(autoApply = true)
public class BooleanToYNConverter implements AttributeConverter<Boolean, String> {

  public String convertToDatabaseColumn(Boolean attribute) {
    return (attribute != null && attribute) ? "Y" : "N";
  }

  public Boolean convertToEntityAttribute(String s) {
    return "Y".equals(s);
  }
}

이렇게하면 자동으로 boolean 값은 모두 컨버터 된다.

리스너

모든 엔티티를 대상으로 언제 어떤 사용자가 삭제를 요청했는지 모두 로그로 남겨야 하는 요구 사항이 있다면 애플리케이션 삭제 로직을 하나씩 찾아서 로그를 남기는 것은 너무 비효율적이다. JPA에 리스너 기능을 사용하면 엔티티의 생명주기에 따른 이벤트를 처리 할 수 있다.

이벤트의 종류
1. PostLoad : 엔티티가 영속성 컨텍스트에 조회된 직후 또는 refresh를 호출한 후
2. PrePersist : persist() 메서드를 호출해서 엔티티를 영속성컨텍스트에 관리하기 직전에 호출 된다. 식별자 생성 전략을 사용한 경우 엔티티에 식별자는 아직 존재 하지 않는다. 새로운 인스턴스를 merge할 때도 수행된다.
3. PreUpdate : flush나 commit을 호출해서 엔티티를 데이터베이스에 수정하기 직전에 호출된다.
4. PreRemove : remove() 메서드를 호출해서 엔티티를 영속성 컨텍스트에서 삭제하기 직전에 호출된다. 또한 삭제 명령어로 영속성 전이가 일어날 때도 호출 된다. orphanRemoval에 대해서는 flush나 commit시 호출 된다.
5. Postpersist : flush나 commit을 호출해서 엔티티를 데이터베이스에 저장한 직후에 호출된다. 식별자가 항상 존재한다. 참고로 식별자 생성 전략이 IDENTITY면 식별자를 생성하기 위해 persist()를 호출한 직후에 바로 Postpersist가 호출 된다.
6. PostUpdate : flush나 commit을 호출해서 엔티티를 데이터베이스에 수정한 직후에 호출 된다.
7. PostRemove : flush나 commit을 호출해서 엔티티를 데이터베이스에 삭제한 직후에 호출된다.

@Entity
@Data
public class Duck {

  @Id @GeneratedValue
  private Long id;

  private String name;

  @PrePersist
  public void prePersist(){
    System.out.println("Duck.prePersist id=" + id);
  }

  @PostPersist
  public void postPersist(){
    System.out.println("Duck.postPersist id=" + id);
  }
  @PostLoad
  public void postLoad(){
    System.out.println("Duck.postLoad");
  }

  @PreRemove
  public void preRemove(){
    System.out.println("Duck.preRemove");
  }

  @PostRemove
  public void postRemove(){
    System.out.println("Duck.postRemove");
  }
}

별도의 리스너 등록

@Entity
@Data
@EntityListeners(DuckListener.class)
public class Duck {

  @Id @GeneratedValue
  private Long id;
}
public class DuckListener {

  @PrePersist
  public void perPersist(Object obj){
    System.out.println("DuckListener.perPersist obj=" + obj);
  }

  @PostPersist
  public void postPersist(Object obj){
    System.out.println("DuckListener.postPersist obj=" + obj);
  }
}

리스너의 파라미터가 특정 타입이 확실하다면 Object이 아닌 특정타입으로 받을 수 있다. 반환타입은 void로 설정해야 한다.

출처 : 자바 ORM 표준 JPA 프로그래밍 (김영한)