[JPA] 즉시 로딩과 지연 로딩 ( + PersistentBag)

 

 

 

 

 

 

지연 로딩과 즉시 로딩

JPA에서는 개발자가 연관된 엔티티의 조회 시점을 선택할 수 있도록 다음 두가지 방법을 제공합니다.

 

 

 

 

 

즉시 로딩 (EAGER LOADING)

@XToX(fetch = FetchType.EAGER)

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

 

 

 

 

 

 

지연 로딩 (LAZY LOADING)

@XToX(fetch = FetchType.LAZY)

연관된 엔티티를 실제 사용할 때 조회합니다. (사용 전까지는 프록시로 조회합니다.)

 

 

 

 

 

 

 

 

 

 

 

 

 

즉시 로딩시 외부 조인(Left Outer Join)이 발생하는 이유

즉시 로딩을 사용할 때, 실행되는 SQL이 내부 조인(Inner Join)이 실행되는 경우가 있고, 외부 조인(Left Outer Join)이 실행되는 경우가 있습니다.

 

이 차이가 발생하는 이유는 무엇일까요?

 

 

 

 

Null 제약조건과 JPA 조인 전략

외래 키에 NULL 값이 허용되는 경우 Inner Join을 사용한다면, 연관된 엔티티가 Null인 경우에는 연관된 엔티티는 물론이고 해당 엔티티도 조회할 수 없어집니다.

 

JPA는 이런 상황을 고려해서 외부 조인을 사용합니다.

 

하지만 외부 조인보다는 내부 조인이 성능과 최적화에서 훨씬 유리합니다.

 

 

 

 

그럼 내부 조인은 언제 사용될까요?

 

외래 키에 NOT NULL 제약조건을 설정하게 되면 값이 있는것을 보장합니다.

따라서 이때는 내부 조인만 사용해도 됩니다.

 

JPA에게 이런 사실을 알려주기 위해 @JoinColumn에 nullable = false를 설정해서 이 외래 키는 NULL 값을 허용하지 않는다고 알려주면, JPA는 외부조인 대신에 내부조인을 사용합니다.

 

또는 @ManyToOne(optinal = false)를 사용하는 방법도 있습니다.

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

컬렉션 래퍼 - PersistentBag

 

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

 

 

 

 

간단한 예시를 들어보겠습니다.

@Getter
@NoArgsConstructor(access = AccessLevel.PROTECTED)
@Entity
@Table(name = "car")
public class Car {

   @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
   @Column(name = "car_id")
   private Long id;

   private String name;


   @ManyToOne(fetch = FetchType.LAZY)
   @JoinColumn(name = "member_id")
   private Member member;

   public void setId(Long id) {
      this.id = id;
   }

   public void setName(String name) {
      this.name = name;
   }
}

@NoArgsConstructor(access = AccessLevel.PROTECTED)
@Entity
@Setter
@Getter
public class Member {

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


   @ElementCollection
   @CollectionTable(name = "MEMBER_NICKNAME", joinColumns = @JoinColumn(name = "MEMBER_ID", referencedColumnName = "MEMBER_ID"))
   private List<String> nickNames = new ArrayList<>();



   @OneToMany(mappedBy = "member")
   private List<Car> cars = new ArrayList<>();
}

 

 

 

 

Member member = new Member();
em.persist(member);

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

Member member1 = em.find(Member.class, 1L);
List<String> a = member.getNickNames();
System.out.println(a.getClass().getName());

List<Car> aa = member.getCars();
System.out.println(aa.getClass().getName());

 

결과는 다음과 같습니다.

 

 

 

엔티티를 지연 로딩하면 프록시 객체를 사용해서 지연 로딩을 수행하지만, 주문 내역같은 컬렉션은 컬렉션 래퍼가 지연 로딩을 처리해줍니다.

 

컬렉션 래퍼도 컬렉션에 대한 프록시 역할을 하므로 따로 구분할 필요는 없어보입니다.

 

 

 

⭐️ 컬렉션이 초기화되는 경우

member.getNickNames().get(0) 이나
member.getNickNames().size() 처럼
컬렉션에서 실제 데이터를 사용할 때 데이터베이스를 조회해서 초기화합니다.

member.getNickNames() 만 호출한다면 컬렉션은 초기화되지 않습니다.

 

 

 

 

 

 

 

 

결론

가급적 지연로딩을 사용하는 것을 권장합니다.

• 즉시 로딩을 적요하면 예상하지 못한 SQL이 발생합니다.
• 즉시 로딩은 JPQL 사용 시 N+1 문제를 일으킵니다. ( em.createQuery("select m from Member m", Member.class)  시, Member에 즉시로딩으로 연관된 엔티티를 그 개수만큼 쿼리를 날려 조회)
• @ManyToOne, @OneToOne은 기본이 즉시 로딩이므로 꼭 지연 로딩으로 설정해주는 것을 권장합니다.

 

 

 

 

 

 

 

 

 

 

 

N+1 문제 예시

@Getter
@NoArgsConstructor(access = AccessLevel.PROTECTED)
@Entity
@Table(name = "car")
public class Car {

   @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
   @Column(name = "car_id")
   private Long id;

   private String name;


   @ManyToOne(fetch = FetchType.EAGER)
   @JoinColumn(name = "member_id")
   private Member member;

   public void setId(Long id) {
      this.id = id;
   }

   public void setName(String name) {
      this.name = name;
   }

   public void setMember(Member member) {
      this.member = member;
   }
}

@NoArgsConstructor(access = AccessLevel.PROTECTED)
@Entity
@Setter
@Getter
public class Member {

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


}

 

위와 같은 상황에서 아래 코드를 실행하겠습니다.

Member member = new Member();
Member member2 = new Member();

Car car = new Car();
car.setName("11");

Car car2 = new Car();
car2.setName("22");
car.setMember(member);
car2.setMember(member2);

em.persist(member);
em.persist(member2);
em.persist(car);
em.persist(car2);


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

System.out.println("=============");
List<Car> cars = em.createQuery("select c from Car c", Car.class).getResultList();

 

결과는 다음과 같습니다.

 

 

 

 

 

 

 

 

 

Reference

자바 ORM 표준 JPA 프로그래밍 - 기본편 - 인프런 | 강의

 

[자바 ORM 표준 JPA 프로그래밍 - 김영한]