devFancy BE Developer

[JPA] 프록시와 연관관계 관리

2023-12-15
devFancy
JPA

이 글은 [자바 ORM 표준 JPA 프로그래밍 - 기본편] 강의를 듣고 정리한 내용입니다.

프록시

  • JPA에서 프록시는 실제 엔티티 객체를 대신하여 데이터베이스 조회를 지연할 수 있는 가짜 객체를 의미한다.

  • 가짜 객체라 해서 실제 엔티티의 동작을 수행하지 못하는 것은 아니다.

    • 실제 엔티티 클래스로부터 상속받아 생성하기 때문에, 실제 클래스와 겉 모양은 같으므로 (이론상) 사용하는 입장에서는 구분하기 않고 사용하면 된다.

em.find() vs em.getReference

  • em.find() 는 데이터베이스를 통해 실제 엔티티 객체를 조회하는 메서드이다.

  • em.getReference()는 데이터베이스 조회를 지연하는 가짜 객체(프록시)를 조회한다. -> DB에 쿼리가 안나가는데 조회가 된다.

    • 실제 엔티티 클래스로부터 상속받지만, 내부는 null 값을 가지고 있다.

    • 하이버네이트가 내부의 라이브러리를 써서 프록시라는 가짜 엔티티를 주게 된다.

  • 프록시 객체는 실제 객체의 참조(target)를 보관한다.

  • 프록시 객체를 호출하면, 프록시 객체는 실제 객체의 메서드를 호출한다.

프록시 객체의 초기화

  • 위의 그림을 통해 프록시 객체의 초기화하는 과정은 다음과 같다.

  1. getName() 메서드를 호출하면 처음에 Member target에 값이 없다. (만약 1차 캐시가 존재한다면 프록시 객체가 아닌 실제 객체를 반환한다)

  2. 그래서 JPA가 영속성 컨텍스트에 진짜 Member 객체를 가져오기 위해 초기화를 요청한다.

  3. 영속성 컨텍스트에는 DB를 조회한다.

  4. 그런 다음 실제 엔티티 객체를 생성해서 Member 엔티티에 넘겨준다.

  5. 그리고 MemberProxy에 있는 Member target을 실제 Member 엔티티(진짜 객체)와 연결시켜준다.

  • 정리하면 getName()을 영속성 컨텍스트를 총해 초기화 요청 및 DB에서 조회한 다음, 가짜 객체를 실제 객체와 연결시켜서 값을 받아온다.

코드로 확인하면 아래와 같다.

public class JpaMain {

    public static void main(String[] args) {
        EntityManagerFactory emf = Persistence.createEntityManagerFactory("hello");
        EntityManager em = emf.createEntityManager();
        EntityTransaction tx = em.getTransaction();

        tx.begin();

        try {
            Member member = new Member();
            member.setName("woochang");
            em.persist(member);

            em.flush();
            em.clear();

            // 실제 엔티티를 조회하는 경우
            Member findMember = em.find(Member.class, member.getId());
            // 프록시를 사용하는 경우
            Member findMember = em.getReference(Member.class, member.getId());
            System.out.println(findMember.getClass().getName());

            tx.commit();
        } catch (Exception e) {
            tx.rollback();
        } finally {
            em.close();
        }

        emf.close();
    }

}

  • EntityManager의 getReference() 메서드를 통해 프록시 객체를 가져온다.

  • 실행 결과로 package명.Member$HibernateProxy$chd0xZ3 이라는 형태로 출력하게 되는데, 이를 통해 프록시 객체임을 확인할 수 있다.

  • 프록시 객체는 메서드 호출(getName()) 과 같이 실제 사용될 때 데이터베이스를 조회해서 실제 엔티티 객체를 생성 후 해당 객체를 참조로 가지게 된다.

  • 이를 프록시 객체의 초기화 라고 한다.

프록시의 특징

  • 프록시 객체는 처음 사용할 때 한 번만 초기화한다.

  • 프록시 객체를 초기화 할 때, 프록시 객체가 실제 엔티티로 바뀌는 것은 아니다.

    • 초기화되면 프록시 객체를 통해서 실제 엔티티에 접근이 가능한 것이다. -> 교체되는게 아니라 프록시는 유지되고 내부에 값이 채워진 것이다.

  • 프록시 객체는 원본 엔티티를 상속받는다. 따라서 타입 체크시 주의해야 한다. -> == 로 비교하는 대신, instanceof로 사용해야 한다)

class ProxyEx {
    private static void logic(Member m1, Member m2) {
        System.out.println("m1 == m2: " + (m1 instanceof Member)); // true
        System.out.println("m1 == m2: " + (m2 instanceof Member)); // true
    }
}

  • 영속성 컨텍스트에 찾는 엔티티가 이미 있으면(1차 캐시), em.getReference()를 호출해도 실제 엔티티를 반환된다.

    • JPA에서는 같은 트랜잭션 안에서 영속 엔티티의 동일성을 보장한다.

  • 초기화는 영속성 컨텍스트의 도움을 받아야 하기에 준영속 상태의 프록시를 초기화하면 문제가 발생한다.

프록시 확인

해당 객체가 프록시인지 확인하는 방법은 다음과 같다.

  • PersistenceUnitUtil.isLoaded(Object entity) : 프록시 인스턴스의 초기화 여부 확인

  • entity.getClass().getName() : 프록시 클래스 확인하는 방법

  • org.hibernate.Hibernate.initialize(entity); : 프록시 강제 초기화 (JPA 표준은 강제하는 초기화가 없다)

즉시 로딩과 지연 로딩

즉시 로딩

  • 즉시로딩은 엔티티를 조회할 때 연관관계가 있는 실제 엔티티도 함께 조회하는 방법이다.

  • 즉시 로딩을 사용하기 위해서는 fetch 속성을 FetchType.EAGER 으로 지정하면 된다.

@Entity
public class Member {
    // ...
    @ManyToOne(fetch = FetchType.EAGER) // 즉시 로딩
    @JoinColumn(name = "TEAM_ID")
    private Team team;
    // ...
}

  • 즉시 로딩을 사용하면, JPA 구현체가 가능하면 조인을 사용해서 SQL에서 한번에 함께 조회하게 된다.

    • 이때 외부 조인(left outer join) 을 사용하는 것을 확인할 수 있는데, 이는 Null 가능성 때문이다.

    • 내부 조인이 외부 조인보다 좋은 이유는 성능이 좋기에 최적화에 유리하지만, 이때 외래키에 NOT NULL 제약조건이 필요하다.

@Entity
public class Member {
    // ...
    @ManyToOne(fetch = FetchType.EAGER) // 즉시 로딩
    @JoinColumn(name = "TEAM_ID", nullable = false)
    private Team team;
    // ...
}

지연 로딩

  • 지연 로딩 은 연관된 엔티티를 실제 사용할 때 조회하는 방법이다.

  • 지연 로딩을 사용하기 위해서는 fetch 속성을 FetchType.LAZY 으로 지정하면 된다.

  • 지연 로딩을 사용하게 되는 경우 실제 엔티티 객체 대신 앞에서 설명한 프록시 객체가 들어가게 된다.

  • 아래에서 team이라는 연관된 엔티티를 실제 사용할 때 (ex. team.getName()), 그 시점에 초기화, 즉 DB 조회가 이루어진다는 의미이다.

@Entity
public class Member {
    // ...
    @ManyToOne(fetch = FetchType.LAZY) // 지연로딩
    @JoinColumn(name = "TEAM_ID")
    private Team team;
    // ...
}

  • 지연 로딩은 연관된 엔티티(team)를 사용할 때에만 프록시 객체를 통해 조회하는 반면, 즉시 로딩은 연관된 엔티티를 사용하지 않더라도 실제 객체를 통해 함께 조회가 된다.

  • Member에만 조회하는 경우가 많으면 지연 로딩을 사용하고, Member와 Team을 같이 사용하면 즉시 로딩을 사용하는 걸 권장한다.

프록시와 즉시로딩 주의

  • 실무에서는 가급적 지연 로딩만 사용한다.

    • 즉시 로딩을 적용하면 예상하지 못한 SQL이 발생한다.

    • 즉시 로딩은 JPQL에서 N+1 문제를 일으킨다. -> select로 Member만 가져오는 SQL을 작성했지만, 해당 SQL의 개수만큼 필요하지도 않은 Team select SQL가 발생하게 될 수도 있다.

  • 로딩 전략 - 테이블이 복잡하게 얽혀있는 경우에는 지연 로딩을 사용하는 것을 권장한다.

    • @ManyToOne, @OneToOne은 기본이 즉시 로딩 -> 실무에서 지연 로딩으로 바꾸고 진행한다.

    • @OneToMany, @ManyToMany는 기본이 지연 로딩

예시 - 지연 로딩 활용

  • Member와 Team(다대일)은 자주 함께 사용 -> 즉시 로딩

  • Member와 Order(일대다)는 가끔 사용 -> 지연 로딩

  • Order와 Product(다대일)는 자주 함께 사용 -> 즉시 로딩

영속성 전이: CASCADE

참고로 영속성 전이는 위에서 다룬 프록시 객체와 로딩 전략과 연관이 없는 개념이다)

  • 영속성 전이란 특정 엔티티를 영속 상태로 만들 때, 연관된 엔티티도 함께 영속 상태로 만들고 싶을 때 사용한다.

  • 예를 들어 아래 그림처럼 부모 엔티티를 저장할 때 자식 엔티티도 함께 저장하는 경우에 사용한다.

코드로 적용하면 아래와 같다.

@Getter
@Entity
public class Parent {

    @Id @GeneratedValue
    @Column(name = "PARENT_ID")
    private Long id;

    private String name;


    @OneToMany(mappedBy = "parent", cascade = CascadeType.PERSIST) // 영속성 전이
    private List<Child> children = new ArrayList<Child>();
}
  • 부모만 영속화하면 CascadeType.PERSIST로 설정한 자식 엔티티까지 함께 영속화해서 저장한다.

영속성 전이: CASCADE 주의할 점

  • 영속성 전이는 연관관계를 매핑하는 것과 아무 관련이 없다.

  • 단지, 엔티티를 영속화 할 때 연관된 엔티티도 같이 영속화하는 편리함을 제공할 뿐입니다.

JPA에서 제공하는 CascadeType의 종류는 아래와 같다.

public enum CascadeType{

    ALL, // 모두적용 
    PERSIST, // 영속
    MERGE, // 병합
    REMOVE, // 삭제
    REFRESH, // REFRESH
    DETACH // DETACH
}

  • 주로 ALL 또는 PERSIST만 사용한다.

  • 그리고 다음과 같이 아래 속성을 같이 사용할 수 있다.

cascade = {CascadeType.PERSIST, CascadeType.REMOVE}
  • 참고로 CascadeType.PERSIST, CascadeType.REMOVE는 em.persist(), em.remove()를 실행 할 때 바로 전이가 발생하지 않고 플러시를 호출 할 때 전이가 발생한다.

고아 객체

  • 고아 객체란 부모 엔티티와 연관관계가 끊어진 자식 엔티티를 자동으로 삭제하는 기능을 제공하는 걸 말한다.

  • 이 기능을 사용해서 부모 엔티티의 컬렉션에서 자식 엔티티의 참조만 제거하면 자식 엔티티가 자동으로 삭제하도록 코드를 작성해보면 아래와 같다.

@Entity
public class Parent {

    @Id @GeneratedValue
    @Column(name = "PARENT_ID")
    private Long id;

    private String name;

    @OneToMany(mappedBy = "parent", orphanRemoval = true)
    private List<Child> children = new ArrayList<Child>();
}
  • 고아 객체 제거 기능을 활성화하기 위해 컬렉션에 orphanRemoval = true를 설정하면, 컬렉션에서 제거한 엔티티는 자동으로 삭제된다.
Parent parent1 = em.find(Parent.class, id);
parent1.getChildren().remove(0); //자식 엔티티를 컬렉션에서 제거

  • 사용 코드를 보면 컬렉션에서 첫 번째 자식을 제거한다.

  • 고아 객체 제거 기능은 영속성 컨텍스트를 플러시할 때 적용되므로 플러시 시점에 DELETE SQL이 실행된다.

고아객체 주의할 점

  • 게시판의 첨부파일을 삭제하는 것처럼 참조하는 곳이 하나일 때 사용해야 한다.

  • 쉽게 말해, 특정 엔티티가 개인으로 소유하는 엔티티에만 이 기능을 적용한다.

  • 보통은 @OneToOne, @OneToMany만 가능하다.

  • 만약, 삭제한 엔티티를 다른 곳에서도 참조한다면, 문제가 발생할 수 있다.

영속성 전이 + 고아 객체, 생명주기

  • CascadeType.ALL + orphanRemoval=true 해두면 스스로 생명주기를 관리하는 엔티티는 em.persist()로 영속화, em.remove()로 제거할 수 있다.

    • 두 옵션을 모두 활성화 하면 부모 엔티티를 통해서 자식의 생명주기를 관리할 수 있다.

Reference

Back : [Programmers] 43162. 네트워크(DFS)

Next : [JPA] 값 타입

Comments

Index