<div id="readability-page-1" class="page"><div><p><a href="https://www.inflearn.com/course/ORM-JPA-Basic/dashboard">https://www.inflearn.com/course/ORM-JPA-Basic/dashboard</a></p>
<h2>Proxy</h2>
<h2>Proxy 기초</h2>
<ul>
<li>em.find() vs em.getReference()<ul>
<li>em.find(): 데이터베이스를 통해서 실제 엔티티 객제 조회</li>
<li>em.getReference(): 데이터베이스 조회를 미루는 가짜 엔티티 객체 조회<ul>
<li>조회 시점에는 DB로 쿼리가 전송이 안되지만, 실제 사용하는 곳에서 쿼리가 전송 됨.</li>
</ul>
</li>
</ul>
</li>
</ul>
<h3>특징</h3>
<ul>
<li>실제 클래스를 상속 받아서 만들어짐</li>
<li>실제 클래스와 겉모양이 같다.</li>
<li>사용하는 입장에서는 진짜 객체인지? 프록시 객체인지 구분하지 않고 사용하면 된다. (이론상)</li>
<li>프록시 객체는 실제 객체의 참조를 보관 </li>
<li>프록시 객체를 호출하면 프록시 객체는 실제 객체의 메소드 호출</li>
<li>프록시 객체는 처음 사용할때, 한번만 초기화 </li>
<li>프록시 객체를 초기화 할때, 프록시 객체가 실제 엔티티로 바뀌는 것은 아니고, 프록시 객체를 통해 실제 엔티티에 접근</li>
<li>프록시 객체는 원본 엔티티를 상속받음, 따라서 타입 체크시 주의 해야함.<ul>
<li>instance of 사용</li>
</ul>
</li>
<li>영속성 컨텍스트에 찾는 엔티티가 이미 있으면, em.getReference를 호출 해도 실제 엔티티 반환<ul>
<li>영속성 컨텍스트에 있는 엔티티에서 가져 온 경우에는 프록시 객체든, 엔티티 객체든 <code>==</code> 비교시 true여야 하기 때문에 JPA 스펙으로 되어 있음.</li>
<li>em.getReference 조회 하고 나서, 실제 엔티티를 가져오도록 em.find를 사용하더라도 동일하게 프록시 객체를 반환 한다.</li>
</ul>
</li>
</ul>
<pre><code>Member findMember = entityManager.getReference(Member.class, member1.getId());  
System.out.println("findMember: " + findMember.getClass());  
Member findMember1 = entityManager.find(Member.class, member1.getId());

// 같은 프록시 객체가 리턴 됨.</code></pre>
<ul>
<li>영속성 컨텍스트의 도움을 받을 수 없는 준영속 상태일때, 프록시를 초기화하면 문제 발생<pre><code>Member findMember = entityManager.getReference(Member.class, member1.getId());  
entityManager.detach(findMember);  
// entityManager.close();
System.out.println("findMember: " + findMember.getClass());</code></pre>
</li>
</ul>
<h3>Proxy 확인</h3>
<ul>
<li>프록시 인스턴스의 초기화 여부 확인<ul>
<li>PersistenceUnitUtil.isLoaded(Object entity)</li>
</ul>
</li>
<li>프록시 클래스 확인 방법<ul>
<li>entity.getClass().getName()</li>
</ul>
</li>
<li>프록시 강제 초기화<ul>
<li>org.hibernete.Hibernate.initialize(entity)</li>
</ul>
</li>
</ul>
<pre><code>Member findMember = entityManager.getReference(Member.class, member1.getId());  
//            entityManager.close();  
 System.out.println("isLoaded: " + entityManagerFactory.getPersistenceUnitUtil().isLoaded(findMember));  
//            Hibernate.initialize(findMember);  
 System.out.println("findMember: " + findMember.getClass());</code></pre>
<h2>즉시 로딩과 지연 로딩</h2>
<pre><code>fetch = FetchType.LAZY</code></pre>
<pre><code>@Entity  
public class Member extends BaseEntity {  
 @Id  
 @GeneratedValue @Column(name = "MEMBER_ID")  
 private Long id;  
 @Column(name = "USERNAME", nullable = false)  
 private String name;  
 //    @Column(name = "TEAM_ID")  
//    private Long teamId;  
 @ManyToOne(fetch = FetchType.LAZY)  
 @JoinColumn(name = "TEAM_ID")  
 private Team team;
 ...
 ...
}</code></pre>
<p>LAZY로 설정시, 프록시로 가져오게 된다. </p>
<pre><code>Member findMember = entityManager.find(Member.class, member1.getId());  
System.out.println("findMember.team: " + findMember.getTeam().getClass()); 
findMember.getTeam().getName() // 해당 시점에 Team을 사용하기 때문에, 이 때 초기화가 된다.</code></pre>
<p>그런데, Member와 Team을 자주 함께 사용한다면? </p>
<pre><code>@Entity  
public class Member extends BaseEntity {  
 @Id  
 @GeneratedValue @Column(name = "MEMBER_ID")  
 private Long id;  
 @Column(name = "USERNAME", nullable = false)  
 private String name;  
 //    @Column(name = "TEAM_ID")  
//    private Long teamId;  
 @ManyToOne(fetch = FetchType.EAGER)  
 @JoinColumn(name = "TEAM_ID")  
 private Team team;
 ...
 ...
}</code></pre><p>FetchType을 EAGER로 변경하면 즉시 로딩이 된다.<br>JPA 구현체는 가능하면 조인을 사용해서 SQL 한번에 함께 조회 한다. </p>
<h3>프록시와 즉시로딩 주의점</h3>
<ul>
<li>가급적 지연 로딩만 사용 (실무에서)<ul>
<li>즉시 로딩을 적용하면 예상하지 못한 SQL이 발생.</li>
<li>즉시 로딩은 JPQL에서 N+1 문제 발생.<ul>
<li>SQL로 바로 번역 되는 JPQL에서는 EAGER인 경우, 데이터 초기화를 위해서 또 SQL이 발생 되는 구조라서 N+1 문제가 발생하게 됨.</li>
</ul>
</li>
</ul>
</li>
<li><code>@ManyToOne</code>, <code>@OneToOne</code>은 기본이 즉시 로딩 -&gt; Lazy로 설정</li>
<li><code>@OneToMany</code>, <code>@ManyToMany</code>는 기본이 지연 로딩</li>
</ul>
<h4>지연 로딩 활용</h4>
<p>이론적으로 이런 조합의 경우에는 방식을 분리하지만, 실무에서는 무조건 지연 로딩을 사용해야 한다.</p>
<ul>
<li>Member와 Team은 자주 함께 사용 -&gt; 즉시 로딩 </li>
<li>Member와 Order는 가끔 사용 -&gt; 지연 로딩</li>
<li>Order와 Product는 자주 함께 사용 -&gt; 즉시 로딩 </li>
</ul>
<h5>실무의 경우</h5>
<ul>
<li>모든 연관관계에 지연 로딩을 사용해라</li>
<li>실무에서는 즉시 로딩 사용 지양해라</li>
<li>JPQL fetch 조인이나, Entity Graph 기능을 사용해라</li>
</ul>
<h2>영속성 전이 (CASCADE)</h2>
<ul>
<li>특정 엔티티를 영속 상태로 만들 때 연관된 엔티티도 함께 영속상태로 만들고 싶을때</li>
</ul>
<pre><code>@OneToMany(mappedBy = "parent", cascade = CascadeType.ALL)  
private List&lt;Child&gt; childList = new ArrayList&lt;&gt;();</code></pre>
<p>Parent를 통해서 Child들까지도 영속상태로 만들고 싶을때 위처럼 사용하면 된다.</p>
<h3>주의점</h3>
<ul>
<li>영속성 전이는 연관관계를 매핑하는 것과 아무 관련이 없음</li>
<li>엔티티를 영속화 할 때, 연관된 엔티티도 함께 영속화 하는 편리성만 제공</li>
<li>하나의 부모 - 자식 관계 엔티티에서 쓰면 용이함.<ul>
<li>단일 소유 관계이거나, 엔티티 라이프 사이클이 의존적으로 동일할때 써야함.</li>
</ul>
</li>
</ul>
<h3>종류</h3>
<ul>
<li>ALL: 모두 적용</li>
<li>PERSIST: 영속</li>
<li>REMOVE: 삭제 </li>
<li>MERGE: 병합</li>
<li>REFRESH</li>
<li>DETACH</li>
</ul>
<h2>고아 객체</h2>
<ul>
<li>부모 엔티티와 연관관계가 끊어진 자식 엔티티를 자동으로 삭제 </li>
<li><code>orphanRemoval = true</code></li>
</ul>
<pre><code>@OneToMany(mappedBy = "parent", cascade = CascadeType.ALL, orphanRemoval = true)</code></pre>
<h3>주의점</h3>
<ul>
<li>참조가 제거된 엔티티는 다른 곳에서 참조하지 않는 고아 객체로 보고 삭제 </li>
<li>참조하는 곳이 하나일 때만 사용할 것</li>
<li>특정 엔티티가 개인 소유할 때만 사용</li>
<li><code>@OneToOne</code>, <code>@OneToMany</code>만 가능</li>
<li>부모를 제거하면, 자식은 고아가 된다. 따라서 고아 객체 제거 기능을 활성화 하면, 부모를 제거 하면 자식도 함께 제거 된다. 이는 마치 CascadeType.REMOVE처럼 동작하게 된다.</li>
</ul>
<h3>영속성 전이 + 고아 객체</h3>
<ul>
<li>CascadeType.ALL + orphanRemoval = true<ul>
<li>스스로 생명주기를 관리하는 엔티티는 em.persist()로 영속화, em.remove()로 제거</li>
<li>두 옵션을 모두 활성화 하면 부모 엔티티를 통해서 자식의 생명주기를 관리할 수 있음.</li>
<li>도메인 주도 설계의 Aggregate Root개념을 구현할 때 유용</li>
</ul>
</li>
</ul>
<h2>실전 예제</h2>
<h3>Global Fetch 전략 설정</h3>
<ul>
<li>모든 연관관계를 지연 로딩으로 처리 </li>
<li>@ManyToOne, @OneToOne은 기본이 즉시 로딩이므로 지연로딩으로 변경</li>
</ul>
<h3>영속성 전이 설정</h3>
<ul>
<li>Order -&gt; Delivery를 영속성 전이 ALL 설정</li>
<li>Order -&gt; OrderItem을 영속성 전이 ALL 설정</li>
</ul>
            
</div></div>

Seungdols Company

seungdols

https://www.inflearn.com/course/ORM-JPA-Basic/dashboard Proxy Proxy 기초 em.find() vs em.getReference() em.find(): 데이터베이스를 통해서 실제 엔티티 객제 조회 em.getReference(): 데이터베이스 조회를 미루는 가짜 엔티티 객체 조회 조회 시점에는 DB로 쿼리가 전송이 안되지만, 실제 사용하는 곳에서 쿼리가 전송 됨. 특징 실제 클래스를 상속 받아서 만들..            
카카오스토리
트위터
페이스북
'프로그래밍 > JPA' 카테고리의 다른 글
고급 매핑 전략  (0)
22:03:32
다양한 연관관계 매핑  (0)
22:02:28
연관관계 매핑  (0)
22:01:04
엔티티 맵핑  (0)
21:58:06
영속성 관리  (0)
21:56:23

프록시와 연관관계

댓글