LAZY 전략의 Proxy

🎬 Intro

LAZY 전략에서 사용하는 Proxy에 대해 알아봅시다.

✅ LAZY

• JPA 연관관계에서 연관된 엔티티를 가져올때 사용하는 전략 중 하나이다.
• 연관된 엔티티를 가져오는 시점에서 실제 엔티티를 가져오지 않고 프록시 형태로 가져오게 된다.
• 프록시 객체는 사용되는 시점에 쿼리가 발생한다. 때문에 N + 1 문제가 발생 할 수 있다.

✅ Proxy

• 실제 엔티티가 아닌 가짜 객체이다.
• 프록시 객체의 초기화는 한번만 일어난다. 사용되는 시점 or Hibernate.initialize() 를 통해서 초기화 된다. 초기화 된 데이터는 영속성 컨텍스트 1차 캐시에 저장된다.
• 프록시 객체가 초기화 되더라도 객체에 추가로 연관된 엔티티와의 연관관계 전략이 LAZY라면 해당 엔티티를 프록시로 가져온다.
• 프록시 객체는 절대로 실제 객체로 바뀌지 않는다. 즉, 초기화가 되더라도 프록시 객체로 남는다.
• 프록시 객체는 사용되는 시점에 DB에서 정보를 가져온다.
• 프록시 객체를 통해 DB에서 정보를 가져올려면 트랜잭션안에 있어야한다. 트랜잭션이 없는데 프록시 객체를 통해서 정보를 가져올려고 하면 LazyInitializationException이 발생한다.

📝 예제

@Entity
@Table
@NoArgsConstructor(access = AccessLevel.PROTECTED)
@Data
public class Book {

  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  private Long id;

  private String title;

  private String author;

  @ManyToOne(fetch = FetchType.LAZY)
  @JoinColumn(name = "book_store_id")
  private BookStore bookStore;

  @Builder
  public Book(final Long id, final String title, final String author, final BookStore bookStore) {
    this.id = id;
    this.title = title;
    this.author = author;
    this.bookStore = bookStore;
  }

}


@Entity
@Table
@NoArgsConstructor(access = AccessLevel.PROTECTED)
@Data
public class BookStore {

  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  private Long id;

  private String name;
  @Builder
  public BookStore(final Long id, final String name) {
    this.id = id;
    this.name = name;
  }
}

@Service
@RequiredArgsConstructor
public class BookService {


  private final BookRepository bookRepository;
  private final BookStoreRepository bookStoreRepository;
  private final EntityManager em;


  @Transactional
  public BookStore getProxyBookStore() {

    BookStore bookStore = BookStore.builder()
      .name("테스트 북스토어1")
      .build();

    Book book = Book.builder()
      .title("테스트 북1")
      .bookStore(bookStore)
      .build();

    bookStoreRepository.save(bookStore);
    bookRepository.save(book);

    // 프록시 객체를 가져오기 위해 DB에 내용을 반영하고, 1차 캐시를 지운다.
    em.flush();
    em.clear();

    // save를 하는 시점에서 book의 id가 자동으로 할당 된다.
    // 따라서 1차 캐시를 지우더라도 id는 이미 할당된 상태
    Long bookId = book.getId();

    // book를 가져오면 LAZY 전략에 의해 bookStore는 프록시 객체로 가져와진다.
    Book getBook = bookRepository.findById(bookId).orElse(null);

    BookStore getBookStore = getBook.getBookStore();

    /**
     * 프록시 객체를 강제로 초기화한다. 따라서 실제 객체에 필요한 정보를 전부 가져온다.
     * 북스토어와 추가로 연관된 엔티티들은 LAZY일 경우 프록시로 가져오고, EAGER라면 즉시 가져온다.
     */
    // Hibernate.initialize(getBookStore);

    return getBookStore;

  }
}

• 프록시 객체를 가져오기 위해 em.flush()를 호출하여 영속성 컨텍스트에 쌓인 쿼리를 실행하고, em.clear()를 호춣하여 1차 캐시를 지운다.
• book의 id는 save하는 시점에 실제 객체에 저장되기 때문에 1차 캐시를 지워도 id 값을 가져올 수 있다.
• findBy()를 통해 저장한 book을 가져오면 이와 연관된 bookStore는 LAZY 전략에 의해 프록시 객체로 가져와진다.
• Hibernate.initialize()를 통해서 프록시 객체를 초기화할 수 있다. 이때 해당 엔티티에 필요한 정보를 모두 가져오게 된다. 만약 BookStore에 선언된 엔티티의 연관관계 전략이 LAZY라면 연관된 객체는 프록시 객체로, EAGER라면 연관된 엔티티의 실제 객체를 가져온다.
• 결과적으로 getProxyBookStore() 는 BookStore 프록시 객체를 반환한다.

@SpringBootTest
public class JpaTest6 {

  @Autowired
  private BookService bookService;

  private BookStore proxyBookStore;


  @BeforeEach
  void setUp() throws Exception {

    proxyBookStore = bookService.getProxyBookStore();

  }

  @DisplayName("LazyInitializationException 발생 성공 테스트")
  @Test
  void proxyTest1() throws Exception {
    // given

    System.out.println("proxyBookStore : " + proxyBookStore.getClass());
    System.out.println("BookStore : " + BookStore.class);

    // when

    // then

    // 프록시 북 스토어는 프록시 타입이다.
    assertThat(proxyBookStore).isInstanceOf(HibernateProxy.class);
    // 프록시 북 스토어는 북 스토어 인스턴스 타입이다.
    assertThat(proxyBookStore).isInstanceOf(BookStore.class);
    // 프록시 북 스토어의 클래스는 북스토어 클래스와 동일하지 않다.
    assertThat(proxyBookStore.getClass()).isNotEqualTo(BookStore.class);
    assertThatThrownBy(() -> proxyBookStore.getName())
      .isInstanceOf(LazyInitializationException.class);
  }

  @DisplayName("LazyInitializationException 발생 실패 테스트")
  @Test
  @Transactional
  void proxyTest2() throws Exception {
    //given

    //when

    //then

    assertThat(proxyBookStore.getName()).isNotNull();
    assertThat(Hibernate.isInitialized(proxyBookStore)).isTrue();

  }
}

proxyBookStore : class com.example.jparemind1.domain1.BookStore$HibernateProxy$ULvIdbkE
BookStore : class com.example.jparemind1.domain1.BookStore

proxyTest1()

• getProxyBookStore()에서 반환한 bookStore를 출력해보면 프록시 객체라는것을 알 수 있다.
• HibernateProxy.class는 프록시 객체 타입이다. 따라서 bookStore는 해당 타입과 같다.
• bookStore는 프록시 객체 이지만 인스턴스 타입은 BookStore.class와 같다.
• 하지만 실제 bookStore의 실제 class 는 BookStore.class와 같지 않다.
• 따라서 둘의 비교는 “==” 동일성으로 하면 안된다.

  proxyTest2()

• getProxyBookStore()의 트랜잭션과 테스트 proxyTest2()의 트랜잭션이 묶여 있기 때문에 proxyTest2() 테스트가 끝나는 시점에 롤백이 된다. 따라서 실제로 DB에 SELECT을 제외한 쿼리는 실행되지 않는다.
• proxyBookStore가 getName()을 통해 초기화 되었다. 따라서 Hibernate.isInitialized()는 true를 반환한다.

✨ Summary

• LAZY 전략은 연관된 엔티티를 지연 로딩하여 처음엔 프록시 객체로 가져오고, 실제 사용 시 DB에서 데이터를 조회하는 방식이다.
• 프록시 객체는 실제 엔티티를 대리하며, 초기화될 때까지는 가짜 객체로 남아 있다. 초기화 후에도 프록시 객체 자체는 실제 엔티티로 바뀌지 않는다.
• Hibernate.initialize()는 프록시 객체를 강제로 초기화하여, 실제 데이터를 DB에서 가져온다. 트랜잭션 내에서만 초기화가 가능하다.
• 프록시 객체는 동일성(==) 비교를 하면 안된다. 프록시의 클래슨느 실제 엔티티 클래스와 다르다. 따라서 instanceof로 비교해야한다.
• 트랜잭션 내에서 프록시 객체가 초기화 되면 LazyInitializationException이 발생하지 않는다.