JPA 프로그래밍 스터디 8장 정리

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

 

• 프록시와 즉시로딩, 지연로딩

프록시를 사용하면 연관된 객체를 처음부터 데이터베이스에서 조회하는것이 아니라, 실제 사용하는 시점에 데이터베이스에서 조회할 수 있다.

하지만 자주 함께 사용하는 객체들은 조인을 사용해서 함께 조회하는 것이 효과적이다. JPA는 즉시 로딩과 지연 로딩이라는 방법으로 둘을 모두 지원한다.

 

• 영속성 전이와 고아 객체

JPA는 연관된 객체를 함께 저장하거나 함께 삭제할 수 있는 영속성 전이와 고아 객체 제거라는 편리한 기능을 제공한다.

 

✅ 8.1 프록시

• 회원과 팀의 단방향 연관관계

@Entity
@Data
public class Member {
    private String username;

    @ManyToOne
    private Team team;
}
@Entity
@Data
public class Team {
    private String name;
}

 

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

@Test
@DisplayName("회원과 팀 정보를 출력하는 비즈니스 로직")
void printUserAndTeam(){
    Member findMember = em.find(Member.class, "member1");
    Team team = findMember.getTeam();
    System.out.println("findMember = " + findMember.getUsername());
    System.out.println("team.getName() = " + team.getName());
}

select
    member0_.username as username1_0_0_,
    member0_.team_name as team_nam2_0_0_,
    team1_.name as name1_1_1_ 
from
    member member0_ 
left outer join
    team team1_ 
        on member0_.team_name=team1_.name 
where
    member0_.username=?

 

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

@Test
@DisplayName("회원과 팀 정보를 출력하는 비즈니스 로직")
void printUser(){
    Member member1 = em.find(Member.class, "member1");
    System.out.println("member1.getUsername() = " + member1.getUsername());
}

printUser() 메소드는 회원 엔티티만 사용하므로 em.find()로 회원 엔티티를 조회할 때 회원과 연관된 팀 엔티티까지 데이터베이스에서 함께 조회해 두는 것은 효율적이지 않다.

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

 

그런데 지연 로딩 기능을 사용하려면 실제 엔티티 객체 대신에 데이터베이스 조회를 지연할 수 있는 가짜 객체가 필요한데 이것을 프록시 객체라 한다.

• 하이버네이트는 지연로딩을 지원하기 위해 2가지를 지원한다
  • 1. 프록시 사용
  • 2. 바이트 코드 수정 - 매우 설정이 복잡하다 .
       • 바이트코드 수정 방법은 하이버네이트 공식 사이트를 참고

 

🔸 8.1.1 프록시 기초

JPA에서 식별자로 엔티티 하나를 조회할 때는 em.find()를 사용한다. 이 메소드는 영속성 컨텍스트에 엔티티가 없으면 데이터베이스를 조회한다.

Member member = em.find(Member.class, "member1");

이렇게 엔티티를 직접 조회하면 조회한 엔티티를 실제 사용하든 사용하지 않든 데이터베이스를 조회하게 된다. 엔티티를 실제 사용하는 시점까지 데이터베이스 조회를 미루고 싶으면 em.getReference() 메소드를 사용하면 된다.

• JpaRepository.getOne 또는 getById가 엔티티매니저의 이 메서드를 사용하고 있다.
• 요청한 인스턴스가 데이터베이스에 없으면 인스턴스 상태에 처음 액세스할 때 EntityNotFoundException이 발생한다.

Member member = em.getReference(Member.class, "member1");

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

 

• 프록시의 특징

 

프록시 클래스는 실제 클래스를 상속 받아서 만들어지므로 실제 클래스와 겉 모양이 같다.

따라서 사용하는 입장에서는 이것이 진짜 객체인지 프록시 객체인지 구분하지 않고 사용하면 된다.

 

프록시 객체는 실제 객체에 대한 참조(target)를 보관한다. 그리고 프록시 객체의 메소드를 호출하면 프록시 객체는 실제 객체의 메소드를 호출한다.

• 디버그를 돌려보면, 지연로딩 상태인 객체들은 프록시 클래스이다.

 

• 프록시 객체의 초기화

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

 

class MemberProxy extends Member {
    Member target = null; // 실제 엔티티 참조
    public String getName(){
        if(target == null){
            // 2. 초기화 요청
            // 3. DB 조회
            // 4. 실제 엔티티 생성 및 참조 보관
            this.target = ...;
        }
        // target.getName();
        return target.getName();
    }
}

 

프록시의 초기화 과정을 분석

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

 

프록시의 특징

1. 프록시 객체는 처음 사용할 때 한 번만 초기화된다.
2. 프록시 객체를 초기화한다고 프록시 객체가 실제 엔티티로 바뀌는것이 아니라 프록시 객체가 초기화되면 프록시 객체를 통해서 실제 엔티티에 접근할 수 있다.
3. 프록시 객체는 원본 엔티티를 상속받은 객체이므로 타입 체크 시에 주의해서 사용해야 한다.
4. 영속성 컨텍스트에 찾는 엔티티가 이미 있으면 데이터베이스를 조회할 필요가 없으므로 em.getReference()를 호출해도 프록시가 아닌 실제 엔티티를 반환한다.
5. 초기화는 영속성 컨텍스트의 도움을 받아야 가능하다. 따라서 영속성 컨텍스트의 도움을 받을 수 없는 준영속 상태의 프록시를 초기화하면 문제가 발생한다. 하이버네이트는 org.hibernate.LazyInitializationException 예외를 발생 시킨다.
   • 트랜잭션이 끝나면 영속성 컨텍스트가 닫힌다. 반드시 트랜잭션과 영속성 컨텍스트 내에서 접근하여 사용하거나, 미리 프록시를 초기화 해놓은상태로 접근을 해야한다.
   • 이 때, 계층간에는 엔티티 대신 DTO로 옮기는 것이 중요하다. 영속성 컨텍스트가 닫혀있는데, 다른 계층으로 엔티티를 보내서 초기화 되지 않은 프록시 객체를 접근한다면 LazyInitializationException이 발생한다.
     • 예를 들어, 서비스 계층에서 트랜잭션이 끝나고 영속성 컨텍스트가 닫힌 시점에 반환한 엔티티를 컨트롤러에서 접근하는 등.

 

🔸 8.1.2 프록시와 식별자

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

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

• 프록시 객체는 식별자 값을 가지고 있으므로 식별자 값을 조회하는 team.getId()를 호출해도 프록시를 초기화하지 않는다.
  
  • 단 엔티티 접근 방식을 프로퍼티(@Access(AccessType.PROPERTY))로 설정한 경우에만 초기화하지 않는다.
• 엔티티 접근 방식을 필드로 설정하면 JPA는 getId() 메소드가 id만 조회하는 메소드인지 다른 필드까지 활용해서 어떤 일을 하는 메소드인지 알지 못하므로 프록시 객체를 초기화 한다.
• 연관관계를 설정할 때는 식별자 값만 사용하므로 프록시를 사용하면 데이터베이스 접근 횟수를 줄일 수 있다.
• 참고로 연관관계를 설정할 때는 엔티티 접근 방식을 필드로 설정해도 프록시를 초기화하지 않는다.

 

🔸 8.1.3 프록시 확인

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

• 메소드 반환값으로 알 수 있다. true or false.
  • boolean isLoaded(...); // In PersistenceUnitUtilImpl

 

✅ 8.2 즉시 로딩과 지연 로딩

• 즉시 로딩 : 엔티티를 조회할 때 연관된 엔티티도 함께 조회한다.
  • 조회 쿼리도 조인을 사용한다.
• 지연 로딩 : 연관된 엔티티를 실제 사용할 때 조회한다.
  • 조회 쿼리시 조인을 사용하지 않고 조회한 엔티티만 조회한다.

 

🔸 8.2.1 즉시 로딩

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

Member member = em.find(Member.class, "member1");
Team team = member.getTeam();

회원을 조회하는 순간 팀도 함께 조회한다.

대부분의 JPA 구현체는 즉시 로딩을 최적화하기 위해 가능하면 조인 쿼리를 사용한다.

select
  member0_.username as username1_0_0_,
  member0_.team_name as team_nam2_0_0_,
  team1_.name as name1_1_1_
from
  member member0_
    left outer join
  team team1_
  on member0_.team_name=team1_.name
where
  member0_.username=?

 

🔸 8.2.2 지연 로딩

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

@Test
@DisplayName("지연 로딩 테스트")
void lazyLoadingTest(){
    Member findMember = em.find(Member.class, "member1");
    System.out.println("findMember.getUsername() = " + findMember.getUsername());
    Team team = findMember.getTeam();
    System.out.println("team.getDescription() = " + team.getDescription());
}

select
  member0_.username as username1_0_0_,
  member0_.team_name as team_nam2_0_0_
from
  member member0_
where
  member0_.username=?

select
  team0_.name as name1_1_0_,
  team0_.description as descript2_1_0_
from
  team team0_
where
  team0_.name=?

 

🔸 8.2.3 즉시 로딩, 지연 로딩 정리

처음부터 연관된 엔티티를 모두 영속성 컨텍스트에 올려두는 것은 현실적이지 않고,

필요할 때마다 SQL을 실행해서 연관된 엔티티를 지연 로딩하는 것도 최적화 관점에서 보면 꼭 좋은 것만은 아니다.

 

✅ 8.3 지연 로딩 활용

 

@Entity
@Getter
@Setter
public class Member {
    @Id
    private String id;
    private String username;
    private Integer age;

    @ManyToOne(fetch = FetchType.EAGER)
    private Team team;

    @OneToMany(mappedBy = "member", fetch = FetchType.Lazy)
    private List<Order> orders = new ArrayList<>();
}

• 회원과 팀의 연관관계를 즉시 로딩으로 설정했기 때문에 회원 조회시 연관된 팀 엔티티도 즉시 조회한다.
• 회원과 주문내역의 연관관계를 지연 로딩으로 설정했기 때문에 연관된 주문내역 엔티티는 프록시로 조회해서 실제 사용될 때까지 로딩을 지연한다.

 

🔸 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

• 하이버네이트는 엔티티를 영속 상태로 만들 때 엔티티에 컬렉션이 있으면 컬렉션을 추적하고 관리할 목적으로
  
  원본 컬렉션을 하이버네이트가 제공하는 내장 컬렉션으로 변경하는데 이것을 컬렉션 래퍼라 한다.
• 엔티티를 지연 로딩하면 프록시 객체를 사용해서 지연 로딩을 수행하지만 주문내역 같은 컬렉션은 컬렉션 래퍼가 지연 로딩을 처리해준다.

 

🔸 8.3.2 JPA 기본 페치 전략

• @ManyToOne, @OneToOne : 즉시 로딩
• @OneToMany, @ManyToMany : 지연 로딩

JPA의 기본 페치 전략은 연관된 엔티티가 하나면 즉시 로딩을, 컬렉션이면 지연 로딩을 사용한다.

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

추천하는 방법은 모든 연관관계에 지연 로딩을 사용하는 것이다. 그리고 애플리케이션 개발이 어느 정도 완료단계에 왔을 때

실제 사용하는 상황을 보고 꼭 필요한 곳에만 즉시 로딩을 사용하도록 최적화하면 된다.

 

🔸 8.3.3 컬렉션에 즉시로딩 사용 시 주의점

• 컬렉션을 하나 이상 즉시 로딩하는 것은 권장하지 않는다.
• 컬렉션 즉시 로딩은 항상 외부 조인(outer join)을 사용한다.

 

FetchType.EAGER 설정과 조인 전략을 정리하면 다음과 같다.

• @ManyToOne, @OneToOne
  • (optional = false): 내부조인
  • (optional = true) : 외부조인
• @OneToMany, @ManyToMany
  • (optional = false): 외부 조인
  • (optional = false): 외부 조인

 

✅ 8.4 영속성 전이: CASCADE

특정 엔티티를 영속 상태로 만들 때 연관된 엔티티도 함께 영속 상태로 만들고 싶으면 영속성 전이 기능을 사용하면 된다.

 

@Entity
public class Parent {
    @Id @GeneratedValue
    private Long id;

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

@Entity
public class Child {
    @Id @GeneratedValue
    private Lond id;

    @ManyToOne
    private Parent parent;
}

 

• 부모 1명에 자식 2명을 저장

 

private static void saveNoCascade(EntityManager em){
    //부모 저장
    Parent parent = new Parent();
    em.persist(parent);

    //1번 자식 저장
    Child child1 = new Child();
    child1.setParent(parent); // 자식 -> 부모 연관관계 설정
    parent.getChildren().add(child1); // 부모 -> 자식
    em.persist(child1);

    //2번 자식 저장
    Child child2 = new Child();
    child2.setParent(parent); // 자식 -> 부모 연관관계 설정
    parent.getChildren().add(child2); // 부모 -> 자식
    em.persist(child2);
}

JPA에서 엔티티를 저장할 때 연관된 모든 엔티티는 영속 상태여야 한다.

따라서, 예제를 보면 부모 엔티티를 영속 상태로 만들고 자식 엔티티도 각각 영속 상태로 만든다.

이럴 때 영속성 전이를 사용하면 부모만 영속 상태로 만들면 연관된 자식까지 한 번에 영속 상태로 만들 수 있다.

 

🔸 8.4.1 영속성 전이: 저장

• 영속성 전이를 활성화하는 CASCADE 옵션을 적용

 

@Entity
public class Parent {
    // ...
    @OneToMany(mappedBy = "parent", cascade = CascadeType.PERSIST)
    private List<Child> children = new ArrayList<>();
    // ...
}

• 부모를 영속화할 때 연관된 자식들도 함께 영속화하라고 cascade = CascadeType.PERSIST 옵션을 설정

 

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);
}

• 부모만 영속화하면 cascade = CascadeType.PERSIST로 설정한 자식 엔티티까지 함께 영속화해서 저장한다.
  
  • 자식 엔티티를 save하는 코드가 줄어들 수 있다.
  • 하지만 버그가 생겼을 때 추적한다면, 코드에 직관적으로 나와있지 않으므로 명확하게 찾기 힘들 수도 있다.

 

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

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

 

🔸 8.4.2 영속성 전이: 삭제

방금 저장한 부모와 자식 엔티티를 모두 제거하려면 각각의 엔티티를 하나씩 제거해야한다.

em.remove(child1);
em.remove(child2);
em.remove(parent);

영속성 전이는 엔티티를 삭제할 때도 사용할 수 있다. CascadeType.REMOVE로 설정하고 다음 코드처럼 부모 엔티티만 삭제하면 연관된 자식 엔티티도 함께 삭제된다.

em.remove(parent);

 

🔸 8.4.3 CASCADE 의 종류

• ALL : 모두 적용
• PERSIST : 영속
• MERGE : 병합
• REMOVE : 삭제
• REFRESH : refresh
• DETACH : detach

 

✅ 8.5 고아 객체

JPA는 부모 엔티티와 연관관계가 끊어진 자식 엔티티를 자동으로 삭제하는 기능을 제공하는데 이것을 고아 객체 제거라 한다.

• 고아 객체 제거 기능 설정

@Entity
public class Parent {
    @Id @GeneratedValue
    private Long id;

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

parent1.getChildren().remove(0); // 자식 엔티티를 컬렉션에서 제거

DELETE FROM CHILD WHERE ID = ?

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

따라서 이 기능은 참조하는 곳이 하나일 때만 사용해야 한다. 따라서 @OneToOne, @OneToMany 에서만 사용할 수 있다.

 

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

if. CascadeType.ALL + orphanRemoval = true 를 동시에 사용한다면 ?

일반적으로 엔티티는 EntityManager.persist()를 통해 영속화되고 EntityManager.remove()를 통해 제거된다. 엔티티 스스로 생명주기를 관리한다는 뜻이다.

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

• 자식을 저장하려면 부모에 등록만 하면된다 (CASCADE)

parent.addChild(child1);

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

parent.getChildren().remove(removeObject);

 

✅ 8.7 정리

• JPA 구현체들은 객체 그래프를 마음껏 탐색할 수 있도록 지원하는데 이때 프록시 기술을 사용한다.
• 객체를 조회할 때 연관된 객체를 즉시 로딩하는 방법을 즉시 로딩이라 하고, 연관된 객체를 지연해서 로딩하는 방법을 지연 로딩이라 한다.
• 객체를 저장하거나 삭제할 때 연관된 객체도 함께 저장하거나 삭제할 수 있는데 이것을 영속성 전이라 한다.
• 부모 엔티티와 연관관계가 끊어진 자식 엔티티를 자동으로 삭제하려면 고아 객체 제거 기능을 사용하면 된다.