BOOK 3 - 자바 ORM 표준 JPA 프로그래밍(8)

프록시와 연관관계 관리

  • 프록시와 즉시로딩, 지연로딩
    • 객체는 객체 그래프로 연관된 객체들을 탐색한다.
    • 객체들이 데이터베이스에 저장되어 있기 때문에 연관된 객체를 마음껏 탐색하기 어렵다.
    • 이런 문제를 해결하기 위해 JPA에서 프록시라는 기술을 사용한다.
      • 연관된 객체를 처음부터 데이터베이스에서 조회하는 것이 아니라, 실제 사용하는 시점에 데이터베이스에서 조회할 수 있다.
      • 하지만 자주 함께 사용하는 객체들은 조인을 사용해서 함께 조회하는 것이 효과적이다.
      • JPA는 즉시 로딩과 지연 로딩 방법 모두 지원한다.
  • 영속성 전이와 고아 객체
    • JPA는 연관된 객체를 함께 저장하거나 삭제할 수 있는 영속성 전이와 고아 객체 제거라는 기능을 제공한다.

프록시

  • 예를 들어 회원과 팀 엔티티 관계를 가정해보자.
  • 비즈니스 로직에 따라 회원과 연관된 팀 엔티티는 사용되지 않을 때도 있다.
    • 이 때 회원 엔티티를 조회할 때 팀 엔티티까지 데이터베이스에서 함께 조회하는 것은 효율적이지 않다.
    • 엔티티가 실제 사용될 때까지 데이터베이스 조회를 지연한다.(Lazy Loading)
  • 지연 로딩 기능을 사용하려면 실제 엔티티 객체 대신에 데이터베이스 조회를 지연할 수 있는 가짜 객체가 필요한데, 이것을 프록시 객체라고 한다.

JPA 표준 명세는 지연 로딩의 구현 방법을 JPA 구현체에 위임했다. 앞으로의 내용은 Hibernate 구현체에 대한 내용이다.

프록시 기초

  • find() 메소드를 호출하면 영속성 컨텍스트에 엔티티가 없는 경우 데이터베이스를 조회한다.
    • 조회한 엔티티를 실제 사용하든 사용하지 않든 데이터베이스를 조회한다.
  • EntityManager.getReference() 메서드를 사용하면 엔티티를 실제 사용하는 시점까지 데이터베이스 조회를 미룬다.
    • JPA는 데이터베이스를 조회하지 않고 실제 엔티티 객체를 생성하지 않는다.
    • 데이터베이스 접근을 위임한 프록시 객체를 반환한다.
  • 프록시 클래스는 실제 클래스를 상속받아서 만들어지므로 실제 클래스와 겉모양이 같다.
    • 즉, 사용자는 이것이 진짜 객체인지 프록시 객체인지 구분하지 않고 사용하면 된다.
  • 프록시 객체는 실제 객체에 대한 참조(target)를 보관한다.
    • 프록시 객체의 메소드를 호출하면 프록시 객체는 실제 객체의 메소드를 호출한다.

프록시 객체의 초기화

  • 실제 객체가 사용되는 시점에 데이터베이스를 조회하여 실제 엔티티를 생성하는 것을 프록시 객체의 초기화라고 한다.

    image

    1. 프록시 객체에 member.getName() 을 호출해서 실제 데이터를 조회한다.
    2. 프록시 객체는 실제 엔티티가 생성되어 있지 않으면(target == null) 영속성 컨텍스트에 실제 엔티티 생성을 요청한다. (초기화)
    3. 영속성 컨텍스트는 데이터베이스를 조회해서 실제 엔티티 객체를 생성한다.
    4. 프록시 객체는 생성된 실제 엔티티 객체의 참조를 target 멤버 변수에 보관한다.
    5. 프로시 객체는 실제 엔티티 객체의 getName() 을 호출해서 결과를 반환한다.

프록시의 특징

  • 프록시 객체는 처음 사용할 때 한번만 초기화된다.
  • 프록시 객체를 초기화한다고 프록시 객체가 실제 엔티티로 바뀌는 것은 아니고, 프록시 객체를 통해서 실제 엔티티에 접근할 수 있게 된다.
  • 영속성 컨텍스트에 엔티티가 이미 존재하면 데이터베이스를 조회할 필요가 없으므로 getReference() 를 호출해도 프록시가 아닌 실제 엔티티를 반환한다.
  • 초기화는 영속성 컨텍스트의 도움을 받아야 하기 때문에 준영속 상태의 프록시를 초기화하면 문제가 발생한다.
    • LazyInitializationException 예외가 발생한다.

준영속 상태와 초기화

Member member = em.getReference(Member.class, "id1");
transaction.commit();
em.close();		// 영속성 컨텍스트 종료

member.getName();		// 준영속 상태에서 초기화 시도 -> 예외 발생

프록시와 식별자

  • 엔티티를 조회할 때 식별자 값을 parameter로 전달하는데, 프록시 객체는 이 식별자 값을 보관한다.
    • 따라서 식별자 값을 조회하는 getId() 를 호출해도 프록시를 초기화하지 않는다.
    • 단, 엔티티 접근 방식을 @Access(AccessType.PROPERTY) 로 설정한 경우에만 초기화하지 않는다.
    • 엔티티 접근 방식을 @Access(AccessType.FIELD) 로 설정하면 JPA는 getId() 메서드가 id만 조회하는지 다른 필드까지 활용하는지 알지 못하므로 프록시 객체를 초기화 한다.

프록시 확인

  • JPA가 제공하는 PersistenceUnitUtil.isLoaded(Object entity) 메서드를 사용하면 프록시 인스턴스의 초기화 여부를 확인할 수 있다.

    boolean isLoaded = em.getEntityManagerFactory()
      									 .getPersistenceUnitUtil().isLoaded(entity);
    
  • initialize() 메서드를 사용하면 프록시를 강제로 초기화할 수 있다.

즉시 로딩과 지연 로딩

  • 즉시 로딩
    • 엔티티를 조회할 때 연관된 엔티티도 함께 조회한다.
    • @ManyToOne(fetch=FetchType.EAGER)
  • 지연 로딩
    • 연관된 엔티티를 실제 사용할 때 조회한다.
    • @ManyToOne(fetch=FetchType.LAZY)

즉시 로딩

@Entity
public class Member {
  @ManyToOne(fetch=FetchType.EAGER)
  @JoinColumn(name="TEAM_ID")
  private Team team;
  ...
}
  • JPA 구현체는 즉시 로딩을 최적화하기 위해 연관된 엔티티를 조회할 때 가능하면 조인 쿼리를 사용한다.

    SELECT
    	M.MEMBER_ID AS MEMBER_ID,
    	M.TEAM_ID AS TEAM_ID,
    	M.USERNAME AS USERNAME,
    	T.TEAM_ID AS TEAM_ID,
    	T.NAME AS NAME
    FROM
    	MEMBER M LEFT OUTER JOIN TEAM T
    		ON M.TEAM_ID=T.TEAM_ID
    WHERE
    	M.MEMBER_ID = 'member1'
    

nullable 설정에 따른 조인 전략

  • @JoinColumn(nullable=true) : NULL 허용 => 외부 조인 사용
  • @JoinColumn(nullable=false) : NULL 허용하지 않음 => 내부 조인 사용
  • @ManyToOne(optional=false) 로 설정해도 내부 조인을 사용한다.

지연 로딩

@Entity
public class Member {
  @ManyToOne(fetch=FetchType.LAZY)
  @JoinColumn(name="TEAM_ID")
  private Team team;
  ...
}
  • em.find(Member.class, "member1") 을 호출하면 다음 SQL이 실행된다.

    SELECT * 
    FROM MEMBER
    WHERE MEMBER_ID = 'member1'
    
  • 지연 로딩을 설정하면 team 멤버변수에 프록시 객체를 넣어둔다.

    Team team = member.getTeam();  // 프록시 객체
    team.getName();								 // 실제 객체 사용
    
  • team.getName() 호출로 프록시 객체가 초기화될 때 다음 SQL이 실행된다.

    SELECT * 
    FROM TEAM
    WHERE TEAM_ID = 'team1'
    

프록시와 컬렉션 래퍼

  • 하이버네이트는 엔티티를 영속 상태로 만들 때 엔티티에 컬렉션이 있으면 컬렉션을 추적하고 관리할 목적으로 원본 컬렉션을 하이버네이트가 제공하는 내장 컬렉션으로 변경한다.

    • 이것을 컬렉션 래퍼라 한다.
    Member member = em.find(Member.class, "member1");
    List<Order> orders = member.getOrders();
    System.out.println("orders = " + orders.getClass().getName());
    // orders = org.hibernate.collection.internal.PersistentBag
    
    • 출력 결과에서 하이버네이트 컬렉션 래퍼를 확인할 수 있다.
  • 엔티티를 지연 로딩하면 프록시 객체를 사용해서 지연 로딩을 수행하지만 컬렉션은 컬렉션 래퍼가 지연 로딩을 처리해준다.

JPA 기본 페치 전략

  • fetch 속성의 기본 설정값은 다음과 같다.
    • @ManyToOne , @OneToOne : FetchType.EAGER
    • @OneToMany , @ManyToOne : FetchType.LAZY
  • JPA의 기본 페치 전략은 연관된 엔티티가 하나면 즉시 로딩을, 컬렉션이면 지연 로딩을 사용한다.
    • 컬렉션을 로딩하는 것은 비용이 많이 들고 너무 많은 데이터를 로딩할 수 있기 때문이다.

컬렉션에 FetchType.EAGER 사용 시 주의점

  • 컬렉션과 조인한다는 것은 데이터베이스 테이블로 보면 일대다 조인이다.
    • 일대다 조인은 결과 데이터가 다 쪽에 있는 수만큼 증가하게 된다.
    • 서로 다른 컬렉션을 2개 이상 조인하면 SQL 실행 결과 데이터 수가 NxM… 이 되면서 너무 많은 데이터를 반환할 수 있고, 성능이 저하될 수 있다.
    • 따라서 2개 이상의 컬렉션을 즉시 로딩으로 설정하는 것은 권장하지 않는다.
  • 컬렉션 즉시 로딩은 항상 외부 조인을 사용한다.
    • 일대다 관계를 조인할 때 내부 조인을 사용하면 반대 테이블에서 참조하지 않는 값은 데이터가 조회되지 않는 문제가 발생한다.
    • 이런 문제를 방지하기 위해 JPA는 일대다 관계를 즉시 로딩할 때 항상 외부 조인을 사용한다.

영속성 전이 : CASCADE

  • 특정 엔티티를 영속 상태로 만들 때 연관된 엔티티도 함께 영속 상태로 만들고 싶으면 영속성 전이 기능을 사용하면 된다.
  • JPA는 CASCADE 옵션으로 영속성 전이를 제공한다.
  • 일대다 관계의 Parent - Child 엔티티를 가정해보자.
Parent parent = new Parent();
em.persist(parent);

Child child1 = new Child();
child1.setParent(parent);
parent.getChildren().add(child1);
em.persist(child1);

Child child2 = new Child();
child1.setParent(parent);
parent.getChildren().add(child2);
em.persist(child2);
  • JPA에서 엔티티를 저장할 때 연관된 모든 엔티티는 영속 상태여야 한다.
  • 위 코드에서는 부모 엔티티를 영속 상태로 만들고, 자식 엔티티도 각각 영속 상태로 만든다.

영속성 전이 : 저장

  • 다음과 같이 영속성 전이를 활성화하는 CASCADE 옵션을 적용할 수 있다.

    @Entity
    public class Parent {
      ...
      @OneToMany(mappedBy="parent", cascade=CascadeType.PERSIST)
      private List<Child> children = new ArrayList<Child>();
      ...
    }
    
    • cascade=CascadeType.PERSIST : 부모 엔티티를 영속화할 때 자식 엔티티도 함께 영속화한다.
  • 영속성 전이를 활성화하면 부모 엔티티와 자식 엔티티의 연관관계만 추가해주면 부모 엔티티 영속화할 때 자식 엔티티도 함께 영속화해서 저장한다.

    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);
      
    em.persis(parent);
    

영속성 전이 : 삭제

  • 영속성 전이는 엔티티를 삭제할 때도 사용할 수 있다.

    • CascadeType.REMOVE 로 설정하고 부모 엔티티만 삭제하면 연관된 자식 엔티티도 함께 삭제 된다.
    Parent parent = em.find(Parent.class, 1L);
    em.remove(parent);
    
    • 위 코드를 실행하면 부모는 물론 연관된 자식도 모두 삭제한다.
      • 즉, parent , child1 , child2 데이터를 삭제하는 DELETE SQL이 3번 실행된다.
      • 삭제 순서는 외래 키 제약 조건을 고려해서 자식을 먼저 삭제하고 부모를 삭제한다.
  • CascadeType.REMOVE 를 설정하지 않고 부모 엔티티를 삭제하면 자식 테이블에 걸려있는 외래 키 제약 조건으로 인해 데이터베이스에서 외래 키 무결성 예외가 발생한다.

CASCADE의 종류

public enum CascadeType {
  ALL,			// 모두 적용
  PERSIST,	// 영속
  MERGE, 		// 병합
  REMOVE,		// 삭제
  REFRESH,	// REFRESH
  DETACH		// DETACH
}
  • CascadeType.PERSIST , CascadeType.REMOVE 는 영속성 컨텍스트가 flush될 때 전이가 발생한다.

고아 객체

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

    • 즉, 부모 엔티티의 컬렉션에서 자식 엔티티의 참조만 제거하면 자식 엔티티가 자동으로 삭제된다.
    • 컬렉션에 orphanRemoval=true 를 설정하면 해당 컬렉션에서 제거된 엔티티는 자동으로 삭제된다.
    Parent parent = em.find(Parent.class, id);
    parent.getChildren().remove(0);
    
    • 위 코드를 실행하면 다음과 같은 자식 엔티티 제거 SQL이 실행된다.

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

  • 또한 부모 엔티티를 제거하면 자식 엔티티는 고아가 되기 때문에 부모를 제거하면 자식도 함께 제거된다.