8장. 프록시와 연관관계 관리

Read Book/JPA 프로그래밍

8장. 프록시와 연관관계 관리

nowwater 2023. 3. 2. 22:30

728x90

1. 프록시

엔티티를 조회할 때 연관된 엔티티가 항상 사용되는 것은 아니다.

1.1 프록시

1.1.1 회원과 팀 정보를 출력하는 비즈니스 로직

public void printUserAndTeam(String memberId) {
    Member member = em.find(Member.class, memberId);
    Team team = member.getTeam();

    System.out.println("회원 이름 : " + member.getUserName());
    System.out.println("소속팀 : " + team.getName());
}

1.1.2 회원 정보만 출력하는 비즈니스 로직

public String printUser(String memberId) {
    Member member = em.find(Member.class, memberId);

    System.out.println("회원 이름 : " + member.getUserName());
}

회원 정보만 사용하는 곳에서 연관된 팀 엔티티까지 데이터베이스에서 조회해두는 것은 효율적이지 않다.

지연 로딩
JPA는 엔티티가 실제 사용될 때까지 데이터베이스 조회를 지연하는 방법을 제공한다.

프록시 객체
지연 로딩을 사용하기 위해서는 "가짜 객체"가 필요하다.

// 엔티티 직접 조회 - 영속성 컨텍스트에 없으면 DB 조회
Member member = em.find(Member.class, 100L);

// 엔티티를 실제 사용하는 시점까지 미루는 프록시 객체
Member member = em.getReference(Member.class, 100L);

1.1.3 프록시 객체의 특징

프록시 객체는 실제 객체에 대한 참조(target)를 보관한다.
처음 사용할 때 한 번만 초기화한다. (실제 엔티티가 생성되어 있지 않으면 영속성 컨텍스트에 실제 엔티티 생성을 요청 = 초기화)
프록시 객체가 초기화 되면 프록시 객체를 통해 실제 엔티티에 접근 가능
원본 엔티티를 상속받은 객체, 타입 체크 주의
영속성 컨텍스트에 찾는 엔티티가 이미 있으면 em.getReference()를 호출해도 프록시가 아닌 실제 엔티티를 반환한다.
초기화는 영속성 컨텍스트의 도움을 받아야 가능하다
- 따라서 영속성 컨텍스트의 도움을 받을 수 없는 준영속 상태의 프록시를 초기화하면 문제가 발생한다.
- org.hibernate.LazyInitializationException 예외 발생 !

1.1.4 프록시 초기화 과정

Member 엔티티로 가정

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

1.2 프록시와 식별자

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

따라서 식별자 값을 조회하는 메소드를 호출해도 프록시가 초기화되지 않는다.

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

단 엔티티 접근 방식을 프로퍼티 @Access(AccessType.PROPERTY)로 설정한 경우에만 초기화되지 않는다.

엔티티 접근 방식을 필드 @Access(AccessType.FIELD) 로 설정하면 JPA는 getId() 메소드가
id만 조회하는 메소드인지 다른 필드까지 활용해서 어떤 일을 하는 메소드인지 알지 못하므로 프록시 객체를 초기화한다.

다음과 같이 프록시는 연관관계 설정 시 유용하게 사용 가능하다.

Member member = em.find(Member.class, "member1");
Team team = em.getReference(Team.classm, "team1"); // SQL 실행 X
member.setTeam(team);

연관관계 설정 시 식별자 값만 사용하므로 프록시를 사용하면 데이터베이스 접근 횟수를 줄일 수 있다.

1.3 프록시 확인

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

조회한 엔티티가 진짜 엔티티인지 프록시로 조회한 것인지 확인하려면 클래스명을 직접 출력해보면 된다.

클래스 명 출력 시, 클래스 명 뒤에 ..javassist.. 라 되어 있으면 프록시 (라이브러리 버전에 따라 다름)

2. 즉시로딩과 지연로딩

2.1 즉시 로딩

엔티티를 조회할 때 연관된 엔티티도 함께 조회한다.

즉시 로딩(EAGER LOADING)을 사용하려면 @ManyToOne의 fetch 속성을 FetchType.EAGER로 지정한다.

즉시 로딩을 최적화하기 위해 가능하면 조인 쿼리를 사용한다.

2.1.1 즉시 로딩 설정

@Entity
public class Member {

    //...
    @ManyToOne(fetch = FetchType.EAGER)
    @JoinColumn(name = "TEAM_ID")
    private Team team;
}

2.1.2 즉시 로딩 실행 코드

Member member = em.find(Member.class, "member1");
Team team = member.getTeam();   // 객체 그래프 탐색

2.1.3 즉시 로딩 실행 SQL

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'

=> 즉, 회원과 팀을 조인해서 쿼리 한 번으로 두 엔티티를 모두 조회한다.

현재 회원 테이블의 TEAM_ID 외래 키는 NULL 값을 허용하고 있다.

팀에 소속하지 않은 회원과 팀을 내부 조인하면 팀은 물론이고 회원 데이터도 조회할 수 없다.

따라서 JPA 는 이런 상황을 고려해서 외부 조인을 사용한다.

하지만 일반적으로 외부 조인보다 내부 조인이 성능과 최적화에서 더 유리하다.

따라서 내부 조인을 사용하려면 외래 키에 NOT NULL 제약 조건을 설정하면 값이 항상 있음을 보장할 수 있어 JPA가 내부 조인만 사용하게 한다.

nullable 설정에 따른 조인 전략

@JoinColumn(nullable = true) : NULL 허용(기본값), 외부 조인 사용
@JoinColumn(nullable = false) : NULL 허용 X, 내부 조인 사용
또는 @ManyToOne.optional = false 로 설정해도 내부 조인을 사용한다.

예시

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

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

정리

JPA는 선택적 관계면 외부 조인을 사용하고, 필수 관계면 내부 조인을 사용한다.

2.2 지연 로딩

연관된 엔티티를 실제 사용하는 시점에 JPA가 SQL을 호출해서 조회한다.

지연 로딩(LAZY LOADING)을 사용하려면 @ManyToOne의 fetch속성을 FetchType.Lazy 로 지정한다.

2.2.1 지연 로딩 설정

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

2.2.2 지연 로딩 실행 코드

Member member = em.find(Member.class, "member1");
Team team = member.getTeam();   //프록시 객체
team.getName();                 //실제 사용 순간

2.2.3 지연 로딩 SQL

// em.find(Member.class, "member1");
SELECT * FROM MEMBER
WHERE MEMBER_ID = 'member1'

// team.getName() 호출
SELECT * FROM TEAM
WHERE TEAM_ID = 'team1'

2.3 정리

조회 대상이 영속성 컨텍스트에 이미 있으면 프록시 객체를 사용할 이유가 없다.

=> 실제 객체 사용

지연 로딩 (LAZY)

연관된 엔티티를 프록시로 조회
프록시를 실제 사용할 때 초기화하면서 데이터베이스를 조회

즉시 로딩 (EAGER)

연관된 엔티티를 즉시 조회
하이버네이트는 가능하면 SQL 조인으로 한 번에 조회

3. 지연로딩 활용

3.1 프록시와 컬렉션 래퍼

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

이러한 컬렉션 래퍼가 컬렉션에 대해 지연 로딩을 처리해준다.

참고로 member.getOrders() 를 호출해도 컬렉션은 초기화되지 않는다.

`member.getOrders().get(0)' 처럼 컬렉션에서 실제 데이터를 조회할 때 데이터베이스를 조회해서 초기화하기 때문이다.

내장 컬렉션 : org.hibernate.collection.internal.PersistentBag

3.2 JPA 기본 페치 전략

fetch 속성의 기본 설정값

@ManyToOne, @OneToOne : 즉시 로딩(FetchType.EAGER)
@OneToMany, @ManyToMany : 지연 로딩(FetchType.LAZY

연관된 엔티티가 하나면 즉시 로딩, 컬렉션이면 지연 로딩을 사용한다.

컬렉션을 로딩하는 것은 비용이 많이 들고 잘못하면 너무 많은 데이터를 로딩할 수 있기 때문이다.

모든 연관관계에 지연 로딩을 사용하는 것을 추천한다.

그리고 애플리케이션 개발이 어느 정도 완료단계에 왔을 때 실제 사용하는 상황을 보고 꼭 필요한 곳에만 즉시 로딩을 사용하도록 최적화하면 된다.

SQL을 직접 사용하면 이런 유연한 최적화가 어렵다. ex) SQL로 각각의 테이블 조회해서 처리하다가 조인으로 한 번에 조회하도록 변경하려면 많은 SQL과 애플리케이션 코드 수정..

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

컬렉션을 하나 이상 즉시 로딩하는 것은 권장하지 않는다.
- 컬렉션과 조인한다는 것은 데이터베이스 테이블로 보면 일대다 조인이다.
- 일대다 조인은 결과 데이터가 다 쪽에 있는 수만큼 증가하게 된다.
- 서로 다른 컬렉션을 2개 이상(예를 들어 N, M 테이블) 조인하면 SQL 실행 결과가 N * M 이 되면서 너무 많은 데이터를 반환하여 애플리케이션 성능 저하
컬렉션 즉시 로딩은 항상 외부 조인을 사용한다.
- 예를 들어, 회원과 팀은 다대일 관계.
- 이 둘을 조인할 때 회원 테이블의 외래 키에 not null 제약조건을 걸어두면 모든 회원은 팀에 소속되므로 항상 내부 조인 사용 가능
- 하지만 팀에서 회원으로 일대다 관계 조인 시 회원이 한 명도 없는 팀을 내부 조인하면 팀까지 조회되지 않는다.
@ManyToOne, @OneToOne
- (optional = false) : 내부 조인
- (optional = true) : 외부 조인
@OneToMany, @ManyToMany
- (optional = false) : 외부 조인
- (optional = true) : 내부 조인

4. 영속성 전이_CASCADE

특정 엔티티를 영속 상태로 만들 때 연관된 엔티티도 함께 영속 상태로 만들고 싶을 경우

JPA는 CASCADE 옵션 으로 영속성 전이 제공

쉽게 말해서 영속성 전이를 사용하면 부모 엔티티를 저장할 때 자식 엔티티도 함께 저장할 수 있다.

만약 해당 옵션을 사용하지 않으면 엔티티를 저장할 때, 연관된 모든 엔티티는 영속 상태여야 한다.

ex) 부모 먼저 em.persist() 로 영속 상태로 만든 후, 자식을 생성해 연관관계를 맺고
자식도 em.persist() 로 영속화시켜줘야한다.

4.1 영속성 전이 : 저장

@Entity
public class Parent {
    ...
    @OneToMany(mappedBy = "parent", cascade = CascadeType.PERSIST) // 부모 영속화할 때 연관된 자식들도 함께 영속화 시키는 옵션
    private List<Child> children = new ArrayList<Child>();
    ...
}

4.1.1 CASCADE 사용 코드

private static void saveWithCascade(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);
}

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

4.2 영속성 전이: 삭제

부모 엔티티만 삭제하면 자식 엔티티도 함께 삭제한다.

cascade = CascadeType=REMOVE 옵션 추가.

4.2.1 예전 코드

Parent findParent = em.find(Parent.class, 1L);
Child findChild1 = em.find(Child.class, 1L);
Child findChild2 = em.find(Child.class, 2L);

em.remove(findChild1); // 외래 키 제약조건 고려해서 자식 먼저 삭제
em.remove(findChild2);
em.remove(findParent);

4.2.2 CASCADE 사용 코드

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

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

5. 고아 객체

JPA는 부모 엔티티와 연관관계가 끊어진 자식 엔티티를 자동으로 삭제하는 기능을 제공한다.

부모 엔티티의 컬렉션에서 자식 엔티티의 참조만 제거하면 자식 엔티티가 자동으로 삭제.

5.1 고아 객체 제거 기능 설정

영속성 컨텍스트를 플러시할 때 적용되므로 플러시 시점에 DELETE SQL이 실행된다.

@Entity
public class Parent {

    @Id @GeneratedValue
    private Long id;

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

고아 객체 제거는 참조가 제거된 엔티티는 다른 곳에서 참조하지 않는 고아 객체로 보고 삭제하는 기능이다.

따라서 참조하는 곳이 하나일 때만 사용해야 한다. (특정 엔티티가 개인 소유하는 엔티티에만 이 기능 적용)

=> @OneToOne, @OneToMany 에서만 사용할 수 있다.

또한 부모를 제거하면 자식은 고아가 되므로, 부모 제거 시 자식도 같이 제거된다.

저작자표시