1. 프록시
프록시 객체
지연로딩기능을 사용하기 위해 실제 엔티티 객체 대신에 데이터베이스 조회를 지연할 수 있는 가짜 객체를 의미한다.
지연로딩
엔티티가 실제 사용될 때까지 데이터베이스 조회를 지연하는 방법.
지연로딩의 예를 담은 코드이다.
Member member = em.find(Member.class, memberId);
Team team = member.getTeam();
System.out.println("회원이름 : "+ member.getUserName());
System.out.println("팀명 : "+ team.getName());team.getName() 처럼 실제 값을 사용하는 시점에 데이터베이스에서 데이터를 조회한다.
🔷프록시 기초
EntityManager.find() 메소드는 영속성 컨텍스트에 엔티티가 없으면 데이터베이스를 조회한다.
EntityManager.getReference() 를 사용하면 엔티티를 실제 사용하는 시점까지 데이터베이스 조회를 미룬다. 즉, 실제 엔티티를 반환하지 않고 프록시 객체를 반환한다.
📣 프록시의 구조
프록시 클래스는 실제 클래스를 상속받아서 만들어지므로 실제 클래스와 겉 모양이 같다. 따라서 사용하는 입장에서는 이게 실제 객체인지 프록시인지 구분하지않고 사용하면 된다.
프록시 객체는 실제 객체에 대한 참조를 보관한다. 그리고 프록시 객체의 메소드를 호출하면 프록시 객체는 실제 객체의 메소드를 호출한다.
📣 프록시 객체의 초기화
프록시 객체는 member.getName()처럼 실제 사용될 대 데이터베이스를 조회해서 실제 엔티티 객체를 생성하는데, 이를 프록시 객체의 초기화라 한다.
프록시 클래스의 예상 코드를 보자.
class MemberProxy extends Member{
Member target = null; //실제 엔티티 참조
public String getName(){
if(target == null){
//초기화 요청
//DB조회
//실제 엔티티 생성및 참조 보관
this.target =...;
}
return target.getName();
}
}📣 프록시 특징
- 프록시 객체는 처음 사용할 때 한번만 초기화된다.
- 프록시 객체를 초기화한다고 프록시 객체가 실제 엔티티로 바뀌는 것은 아니다.(초기화되면 프록시 객체를 통해 실제 엔티티에 접근)
- 초기화는 영속성 컨텍스트의 도움을 받아야 가능하다. 따라서 준영속 상태의 프록시를 초기화하면 문제가 발생한다.
🔷프록시와 식별자
엔티티를 프록시로 조회할 때 식별자값을 파라미터로 전달하는데, 프록시객체는 이 식별자 값을 보관한다.
@Access(@AccessType.PROPERTY)사용 -> 식별자 값을 조회하는team.getId()를 호출해도 프록시를 초기화하지 않는다.@Access(@AccessType.FILED)사용 -> getId()가 id만 조회하는지 알 수 없어 프록시 객체를 초기화한다.
프록시는 연관관계를 설정할 때 유용하게 사용할 수 있다.
Member member = em.find(Member.class, "member1");
Team team = em.getReference(Team.class, "team1"); //SQL을 실행하지 않음.
member.setTeam(team);연관관계를 설정할 때 식별자 값만 사용하므로 프록시를 사용하면 데이터베이스 접근횟수를 줄일 수 있다.
🔷프록시 확인
boolean isLoad = emf.getPersistenceUnitUtil().isLoaded(entity);PersistenceUnitUtil.isLoaded(Object entity)를 통해 프록시 인스턴스의 초기화 여부를 확인할 수 있다.
2. 즉시로딩과 지연로딩
JPA는 엔티티의 조회시점을 선택할 수 있도록 두가지 방법을 제공한다.
- 즉시로딩 : 엔티티를 조회할 때 연관된 엔티티도 함께 조회한다.
- 지연로딩 : 연관된 엔티티를 실제 사용할 때 조회한다.
⌛즉시로딩
즉시로딩을 사용하려면 @ManyToOne의 fetch속성을 FetchType.EAGER로 지정한다.
@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(); //객체 그래프 탐색위 코드에서 em.find(Member.class,"member1");로 회원을 조회하는 순간 팀도 함께 조회된다. 이때 회원 조회쿼리, 팀 조회쿼리로 2번 쿼리가 실행될까?
아니다. 대부분의 JPA 구현체는 즉시 로딩을 최적화하기 위해 가능하면 조인 쿼리를 사용한다.
Hibernate:
select
member8_1x0_.MEMBER_ID as MEMBER_I1_26_0_,
member8_1x0_.team_TEAM_ID as team_TEA3_26_0_,
member8_1x0_.username as username2_26_0_,
team8_1x1_.TEAM_ID as TEAM_ID1_46_1_,
team8_1x1_.name as name2_46_1_
from
Member8_1 member8_1x0_
left outer join
Team8_1 team8_1x1_
on member8_1x0_.team_TEAM_ID=team8_1x1_.TEAM_ID
where
member8_1x0_.MEMBER_ID=?이때 JPA가 left outer join 을 한 것을 유심히 봐야한다.
외부조인보다 내부 조인이 성능과 최적화에 더 유리하다. 그럼 내부조인을 사용하기 위해 어떻게 해야할까?
@ManyToOne(fetch = FetchType.EAGER)
@JoinColumn(name = "TEAM_ID", nullable = false )
private Team team;@JoinColumn에 nullable = false 를 설정한다.
혹은
@ManyToOne(fetch = FetchType.EAGER, optional = false)를 설정한다.
⏳ 지연 로딩
지연로딩을 사용하려면 @ManyToOne의 fetch속성을 FetchType.LAZY로 지정한다.
@Entity
public class Member{
@ManyToOne(fetch = FetchType.LAZY)
@JoinColumn(name = "TEAM_ID")
private Team team;
...
}
Member member = em.find(Member.class,"member1");
Team team = member.getTeam(); //객체 그래프 탐색
team.getName(); //팀 객체 실제 사용em.find(Member.class,"member1"); 를 호출 할 때 Team은 조회되지않아서, team변수에는 프록시 객체를 넣어둔다.
team.getName()을 통해 실제 사용될 때 데이터를 실제 데이터베이스에서 조회한다.
참고로, 조회대상이 영속성 컨텍스트에 이미 있으면 프록시 객체를 사용하지않고, 실제 객체를 사용한다.
3. 즉시/지연 로딩 활용
Member 에 Team은 즉시로딩으로 관리할 것이고, Order는 지연로딩으로 관리할 것이다.
@Entity
public class Member {
@Id
@Column(name = "MEMBER_ID")
private String id;
private String username;
@ManyToOne(fetch = FetchType.EAGER)
@JoinColumn(name = "TEAM_ID", nullable = false)
private Team team;
@OneToMany(mapppedBy = "member", fetch = FetchType.LAZY)
privaget List<Order> orders;
//Getter Setter .**텍스트**..
...
}프록시와 컬렉션 래퍼
order처럼 지연로딩으로 설정하면 실제 엔티티 대신에 프록시 객체를 사용한다.
그런데 order는 일반 엔티티가 아니고 리스트형태의 컬렉션이다.
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여기서 컬렉션 래퍼를 사용한다.
컬렉션 래퍼란?
하이버네이트가 엔티티를 영속상태로 만들때 엔티티에 컬렉션이 있으면 컬렉션을 추적하고 관리할 목적으로 원본 컬렉션을 하이버네이트가 제공하는 내장 컬렉션으로 변경하는 것.
컬렉션은 컬렉션 래퍼가 지연로딩을 처리해준다.
JPA 기본 페치 전략
@ManyToOne, @OneToOne : 즉시로딩(FetchType.EAGER)
@OneToMany, @ManyToMany : 지연로딩(FetchType.LAZY)
JPA의 기본 페치 전략은 연관된 엔티티가 하나면 즉시로딩을, 컬렉션이면 지연로딩을 사용한다.
추천하는 방법은 모든 연관관계에 지연로딩을 사용하는 것이다. 꼭 필요한 곳만 즉시로딩을 사용하면 된다.
컬렉션에 FetchType.EAGER 사용시 주의점
- 컬렉션을 두개 이상 즉시로딩하는 것은 권장하지 않는다.(할꺼면 하나만!)
- 컬렉션 즉시 로딩은 항상 외부조인을 사용한다.(JPA가 강제로 외부조인을 사용하도록 함)
@ManyToOne, @OneToOne
- (optional = false) : 내부조인
- (optional = true) : 외부조인
@OneToMany, @ManyToMany
- (optional = false) : 외부조인
- (optional = true) : 외부조인
❓나는 jpa 5.3.1.Final 버전을 사용중인데, 애초에 ToMany 의 optional 옵션이 존재하지 않는다..
@Target({ElementType.METHOD, ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
public @interface OneToMany {
Class targetEntity() default void.class;
CascadeType[] cascade() default {};
FetchType fetch() default FetchType.LAZY;
String mappedBy() default "";
boolean orphanRemoval() default false;
}4. 영속성 전이 : CASCADE
특정 엔티티를 영속 상태로 만들 때 연관된 엔티티도 함께 영속 상태로 만들고 싶으면 영속성 전이 기능을 사용하면 된다.
@Entity
public class Parent {
@Id @GeneratedValue
private Long id;
@OneToMany(mappedBy = "parent")
private List<Child> children = new ArrayList<Child>();
...
}
@Entity
public class Child{
@Id @GeneratedValue
private Long id;
@ManyToOne
privagte Parent parent;
...
}여기서 부모와 자식을 모두 저장한다고 했을 때
//부모 저장
Parent parent = new Parent();
em.persist(parent);
//1번 자식 저장
Child child1 = new Child();
child1.setParent(parent); //자식 -> 부모연관관계 설정
parent.getChildren().add(child); //부모 -> 자식
em.persist(child1);
//2번 자식 저장
Child child2 = new Child();
child2.setParent(parent); //자식 -> 부모연관관계 설정
parent.getChildren().add(child2); //부모 -> 자식
em.persist(child2);
JPA에서 엔티티를 저장할 때 연관된 모든 엔티티는 영속상태여야한다.
따라서 부모엔티티를 먼저 영속상태로 만들고 자식엔티티도 각각 영속상태로 만들어야한다.
영속성 전이 : 저장
영속성 전이를 활성화 한다면?
@Entity
public class Parent{
...
@OneToMany(mappedBy = "parent", cascade = CascadeType.PERSIST)
private List<Child> children = new ArrayList<Child>();
...
부모를 영속화할때 연관된 자식들도 함게 영속화하려고 cascade = CascadeType.PERSIST 옵션을 설정했다.
이렇게 하면 em.persist(parent);시 부모와 자식이 함께 영속화된다.
영속성 전이 : 삭제
영성전이는 엔티티를 삭제할 때도 사용할 수 있다. CascadeType.REMOVE로 설정하고 em.remove(parent);로 부모엔티티만 삭제하면 연관된 자식 엔티티도 함께 삭제된다.
CASCADE의 종류
다양한 옵션이 존재하고, 여러속성을 함께 사용할 수도 있다.
cascade = {Cascade.PERSIST, CascadeType.REMOVE}
참고로 Cascade.PERSIST, CascadeType.REMOVE는 em.persist()나 em.remove()호출할 때 영속성 전이가 발생하지 않고, 플러시할 때 전이가 발생한다.
5. 고아 객체
JPA는 부모 엔티티와 연관관계가 끊어진 자식 엔티티를 자동으로 삭제하는 기능이 있는데, 이를 고아객체 제거라고 한다.
@Entity
public class Parent {
@Id @GeneratedValue
private Long id;
@OneToMany(mappedBy = "parent", cascade = CascadeType.ALL, orphanRemoval = true)
private List<Child> children = new ArrayList<Child>();
...
}이렇게 @OneToMany 옵션으로 orphanRemoval=true 를 활성화하면 부모 엔티티의 컬렉션에서 자식 엔티티의 참조를 제거하면 자동으로 자식엔티티가 삭제된다.
Parent parent = em.find(Parent.class, id);
parent.getChildren().remove(0); //자식 엔티티를 컬렉션에서 제거이렇게 컬렉션에서 제거하면 플러시할 때 적용되므로 플러시 시점에 DELETE SQL이 실행된다.
그런데,
orphanRemoval = true옵션 뿐만아니라cascade = CascadeType.ALL옵션까지 주어야 DELETE 문이 실행된다.
왜그럴까?
찾아보니, JPA 표준에 따르면, CASCADE 속성과 orphanRemoval 은 독립적이지만, Hibernate 구현체에는 CASCADE 영향을 받는다라고 한다.
👆참고링크
고아객체 제거는 참조하는 곳이 하나일때만 사용해야한다. 즉, 특정 엔티티가 개인소유하는 엔티티에만 이 기능을 적용해야한다.
그러한 이유로 @OneToOne, @OneToMany 에만 적용할 수 있다.
6. 영속성 전이 + 고아객체, 생명주기
CascadeType.ALL + orphanRemoval = true를 모두 사용하면 어떻게 될까?
이것은 부모엔티티를 통해서 자식의 생명주기를 관리할 수 있다.
자식을 저장하려면 부모에 등록만 하면된다(CASCADE)
Child child = new Child();
child.setParent(parent); //자식 -> 부모연관관계 설정
parent.getChildren().add(child2); //부모 -> 자식
em.persist(parent);자식을 삭제하려면 부모에서 제거하면 된다(orphanRemoval)
Parent parent = em.find(Parent.class,parentId);
parent.getChildren().remove(removeObject);