[자바 ORM 표준 JPA 프로그래밍] 8장 프록시와 연관관계 관리

프록시를 사용하면 연관된 객체를 처음부터 데이터베이스에서 조회하는 것이 아니라, 실제 사용하는 시점에 데이터베이스에서 조회할 수 있다. 하지만 자주 함께 사용하는 객체들은 조인을 사용해서 함께 조회하는 것이 효과적이다. 
JPA는 즉시 로딩과 지연 로딩이라는 방법으로 둘을 모두 지원한다. 

🎈 8.1 프록시

엔티티를 조회할 때 연관된 엔티티들이 항상 사용되는 것은 아님. 
어떤 비즈니스 로직은 회원은 물론 연관된 팀의 이름도 출력하지만, 어떤 비즈니스 로직에서는 회원 엔티티만 출력하고 연관된 팀 엔티티는 전혀 사용하지 않음. 
JPA는 이런 문제를 해결하려고 엔티티가 실제 사용될 때까지 데베 조회를 지연하는 방법을 제공하는데 이것을 '지연 로딩'이라고 함. 
team.getName() 처럼 팀 엔티티의 값을 실제 사용하는 시점에 데이터베이스에서 팀 엔티티에 필요한 데이터를 조회하는 것. 
지연 로딩 사용하려면 실제 엔티티 객체 대신에 데베 조회를 지연할 수 있는 가짜 객체가 필요한데 이것을 프록시 객체라 함. 


8.1.1 프록시 기초
JPA에서 식별자로 엔티티 하나를 조회할 때는 EntityManager.find()를 사용함. 이 메소드는 영속성 컨텍스트에 엔티티가 없으면 데베를 조회함. 
Member member = em.find(Member.class, "member1");

엔티티를 직접 조회하면 조회한 엔티티를 실제 사용하든 사용하지 않는 데베를 조회하게 됨. 엔티티 실제 사용 시점까지 조회를 미루고 싶으면 EntityManager.getReference()메소드를 사용하면 됨. 
Member member = em.getReference(Member.class, "member1");

이 메소드를 호출할 때 JPA는 데베를 조회하지 않고 실제 엔티티 객체도 생성하지 않음. 대신 데베 접근을 위임한 프록시 객체를 반환함. 


- 프록시의 특징
: 프록시 클래스는 실제 클래스를 상속 받아서 만들어지므로 실제 클래스와 겉 모양이 같음. 
: 프록시 객체는 실제 객체에 대한 참조(target)을 보관함. 프록시 객체의 메소드를 호출하면 프록시 객체는 실제 객체의 메소드를 호출함. 

- 프록시 객체의 초기화
: 프록시 객체는 member.getName()처럼 실제 사용될 때 데베를 조회해서 실제 엔티티 객체를 생성하는데 이것을 프록시 객체의 초기화라 함. 

((프록시 클래스 예상 코드))

- 준영속 상태와 초기화

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

member.getName(); //준영속 상태 초기화 시도,
                                 //org.hibernate.LazyInitializationException 예외 발생

 

위 코드에서 em.close()로 영속성 컨텍스트 종료해서 member는 준영속 상태임. member.getName()을 호출하면 프록시를 초기화해야 하는데 영속성 컨텍스트가 없으므로 실제 엔티티를 조회할 수 없음. 따라서 예외 발생함. 


8.1.2 프록시와 식별자
엔티티를 프록시로 조회할 때 식별자(pk) 값을 파라미터로 전달하는데 프록시 객체는 이 식별자 값을 보관한다. 

Team team = em.getReference(Team.class, "team1"); //식별자 보관
team.getId(); //초기화되지 않음

프록시는 다음 코드처럼 연관관계를 설정할 때 유용하게 사용할 수 있다. 

Member member = em.find(Member.class, "member1");
Team team = em.getReference(Team.class, "team1"); //SQL을 실행하지 않음
member.setTeam(team);

8.1.3 프록시 확인
JPA가 제공하는 PersistenceUnitUtil.isLoaded(Object entity) 메소드를 용하면 프록시 인스턴스의 초기화 여부를 확인할 수 있음. 아직 초기화되지 않은 프록시 인스턴스는 false를 반환, 이미 초기화되었거나 프록시 인스턴스가 아니면 true를 반환함. 

boolean isLoad = em.getEntityManagerFactory().getPersistenceUnitUtil().isLoaded(entity);
//또는 boolean isLoad = emf.getPersistenceUnitUtil().isLoaded(entity);
System.out.println("isLoad = " + isLoad)' //초기화 여부 확인

 

🎈 8.2 즉시 로딩과 지연 로딩

프록시 객체는 주로 연관된 엔티티를 지연 로딩할 때 사용한다. 

Member member = em.find(Member.class, "member1");
Team team = member.getTeam(); //객체 그래프 탐색
System.out.println(team.getName()); //팀 엔티티 사용

-즉시 로딩: 엔티티를 조회할 때 연관된 엔티티도 함께 조회한다. 
em.find(Member.class, "member1")를 호출할 때 회원 엔티티와 연관된 팀 엔티티도 함께 조회한다. 
설정 방법: @ManyToOne(fetch = FetchType.EAGER)

- 지연 로딩: 연관된 엔티티를 실제 사용할 때 조회한다. 
member.getTeam().getName()처럼 조회한 팀 엔티티를 실제 사용하는 시점에 JPA가 SQL을 호출해서 팀 엔티티를 조회한다. 
설정 방법: @ManyToOne(fetch = FetchType.LAZY)

 

8.2.1 즉시 로딩
em.find(Member.class, "member1")로 회원을 조회하는 순간 팀도 함께 조회함. 회원고 팀 두 테이블을 조회해야 하므로 쿼리를 2번 실행할 것 같지만, 대부분의 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'

 

8.2.2 지연 로딩
Team team = member.getTeam(); //프록시 객체
team.getName(); //팀 객체 실제 사용

이처럼 실제 데이터가 필요한 순간이 되어서야 데베를 조회해서 프록시 객체를 초기화한다. 
em.find(Member.class, "member1") 호출 시 실행되는 SQL
SELECT * FROM MEMBER
WHERE MEMBER_ID = 'member1'

team.getName() 호출로 프록시 객체 초기화되면서 실행되는 SQL
SELECT * FROM TEAM
WHERE TEAM_ID = 'team1'



8.2.3 즉시 로딩, 지연 로딩 정리
지연 로딩(LAZY): 연관된 엔티티를 프록시로 조회한다. 프록시를 실제 사용할 때 초기화하면서 데이터베이스를 조회한다. 
즉시 로딩(EAGER): 연관된 엔티티를 즉시 조회함. 하이버네이트는 가능하면 SQL 조인을 사용해서 한 번에 조회함. 

 

🎈 8.3 지연 로딩 활용

멤버와 팀은 즉시 로딩, 멤버와 오더는 지연 로딩, 오더와 프로덕트는 즉시 로딩.

8.3.1 프록시와 컬렉션 래퍼
점선으로 표현한 지연 로딩은 실제 엔티티 대신에 프록시 객체를 사용함. 실제 자신이 사용될 때까지 데베를 조회하지 않음. 

주문내역 조회해보자. 

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

 

하이버네이트는 엔티티를 영속 상태로 만들 때 엔티티에 컬렉션이 있으면 컬렉션을 추적하고 관리할 목적으로 원본 컬렉션을 하이버네이트가 제공하는 내장 컬렉션으로 변경하는데 이것을 컬렉션 래퍼라 한다. 
엔티티를 지연 로딩하면 프록시 객체를 사용해서 지연 로딩을 수행하지만 주문 내역 같은 컬렉션은 컬렉션 래퍼가 지연 로딩을 처리해준다. (컬렉션 래퍼도 컬렉션에 대한 프록시 역할을 하므로 따로 구분 않고 프록시로 부름.)
member.getOrders()을 호출해도 초기화되지 않고, member.getOrders().get(0)처럼 컬렉션에서 실제 데이터 조회할 때 데베 조회해서 초기화함. 


8.3.2 JPA 기본 페치 전략
fetch 속성의 기본 설정값
- @ManyToOne, @OneToMany: 즉시 로딩(FetchType.EAGER)
- @OneToMany, @ManyToMany: 지연 로딩(FetchType.LAZY)

JPA 기본 페치 전략은 연관된 엔티티가 하나면 즉시 로딩을, 컬렉션이면 지연 로딩을 사용함. 
추천하는 방법은 모든 연관관계에 지연 로딩을 사용하는 것. 앱 개발이 완료단계에서 꼭 필요한 곳에만 즉시 로딩을 사용하도록 최적화. 


8.3.3 컬렉션에 FetchType.EAGER 사용 시 주의점
- 컬렉션을 하나 이상 즉시 로딩하는 것은 권장하지 않는다. 
- 컬렉션 즉시 로딩은 항상 외부 조인을 사용한다. 

 

🎈 8.4 영속성 전이: CASCADE

특정 엔티티를 영속 상태로 만들 때 연관된 엔티티도 함께 영속 상태로 만들고 싶으면 영속성 전이 기능을 사용하면 됨. 
영속성 전이를 사용하면 부모 엔티티를 저장할 때 자식 엔티티도 함께 저장할 수 있음. 

부모에 자식 2명을 저장한다면 
JPA에서 엔티티를 저장할 때 연관된 모든 엔티티는 영속 상태여야 한다. 
따라서 부모 엔티티를 영속 상태를 만들고 자식 엔티티도 각각 영속 상태로 만듦. 
영속성 전이 사용하면 부모만 영속 상태로 만들면 연관된 자식까지 한 번에 영속 상태로 만들 수 있음. 


8.4.1 영속성 전이: 저장

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

private static void saveWithCaseCade(EntityManager em) {
    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.persist(parent);
}

영속성 전이는 연관관계 매핑과는 아무 관련이 없다. 
단지 엔티티를 영속화할 때 연관된 엔티티도 같이 영속화하는 편리함을 제공할 뿐.




8.4.2 영속성 전이: 삭제
영속성 전이는 엔티티를 삭제할 때도 사용 가능함. 
CascadeType.REMOVE로 설정하고 부모 엔티티만 삭제하면 연관된 자식 엔티티도 함께 삭제됨. 

Parent findParent = em.find(Parent.class, 1L);
em.remove(findParant);

를 실행하면 DELETE SQL을 3번 실행하고 부모는 물론 연관된 자식도 모두 삭제함. 외래 키 제약조건을 고려해서 자식을 먼저 삭제하고 부모를 삭제함. 
CascadeType.REMOVE를 설정하지 않고 이 코드 실행하면 데베에서 외래 키 무결성 예외가 발생. 


8.4.3 CASCADE의 종류

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

여러 속성을 같이 사용할 수 있고, PERSIST, REMOVE는 실행할 때 바로 전이가 발생하지 않고 플러시를 호출할 때 전이가 발생함. 

🎈 8.5 고아 객체

JPA는 부몸 엔티티와 연관관계가 끊어진 자식 엔티티를 자동으로 삭제하는 기능을 제공하는데 이것을 고아 객체(ORPHAN) 제거라 함. 
부모 엔티티의 컬렉션에서 자식 엔티티의 참조만 제거하면 자식 엔티티가 자동으로 삭제됨. 

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


Parent parent1 = em.find(Parent.class, id);
parent1.getChildren().remove(0); //자식 엔티티를 컬렉션에서 제거

 

실행 결과 SQL은
DELETE FROM CHILD WHERE ID=?

orphanRemoval = true 옵션으로 인해 컬렉션에서 엔티티 제거하면 데베의 데이터도 삭제됨. 
고아 객체 제거 기능은 영속성 컨텍스트를 플러시할 때 적용되므로 플러시 시점에 DELETE SQL이 실행됨. 

고아 객체 제거는 참조가 제거된 엔티티는 다른 곳에서 참조하지 않는 고아 객체로 보고 삭제하는 기능. 이 기능은 참조하는 곳이 하나일 때만 사용해야 함. 
따라서 orphanRemoval은 @OneToOne, @OneToMany에만 사용 가능함. 

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

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

자식을 저장하려면 부모에 등록만 하면 된다(CASCADE)
Parent parent = em.find(Parent.class, parentId);
parent.addChild(child);

자식을 삭제하려면 부모에서 제거하면 된다(orphanRemoval)
Parent parent = em.find(Parent.class, parentId);
parent.getChildren().remove(removeObject);