프록시와 연관관계 관리
by 키위먹고싶다
프록시
- em.find() vs em.getReference()
- em.find() : 데이터베이스를 통해서 실제 엔티티 객체 조회
- em.getReference() : 데이터베이스 조회를 미루는 가짜(프록시) 엔티티 객체 조회
특징
- 실제 클래스를 상속 받아서 만들어짐
- 실제 클래스와 겉모양이 같다.
- 사용하는 입장에서는 진짜 객체인지 프록시 객체인지 구분하지 않고 사용하면 된다.
- 프록시 객체는 실제 객체의 참조를 보관한다.
- 프록시 객체를 호출하면 프록시 객체는 실제 객체의 메소드를 호출한다.
- 프록시 객체는 처음 사용할 때 한번만 초기화.(한번 만들어지면 그걸로 계속 사용,)
- 프록시 객체를 초기화 할때, 프록시 객체가 실제 엔티티로 바뀌는 것이 아님. 초기화 되면 프록시 객체를 통해 실제 엔티티에 접근 가능.
- 포륵시 객체는 원본 엔티티를 상속받는다. 따라서 타입 체크 시 주의해야 한다/ ==비교 대신, instance of를 사용한다.
- 영속성 콘텍스트에 찾는 엔티티가 있으면 em.getReference()를 호출해도 실제 엔티티를 반환한다. (1차캐시에 있는데 그걸 굳이 프록시를 사용하는 것은 비효율적임, )
- 영속성 컨텍스트의 도움을 받을 수 없는 준영속 상태일 때, 프록시를 초기화하면 문제 발생.(
하이버네이트는 org.hibernate.LazyInitializationException 예외를 터트림)
즉시 로딩과 지연 로딩
@ManyToOne(fetch = FetchType.LAZY)
@JoinColumn(name = "TEAM_ID")
private Team team;
member1을 가져올 때 team을 가져오면 프록시로 조회된다.
@ManyToOne(fetch = FetchType.EAGER)
@JoinColumn(name = "TEAM_ID")
private Team team;프록시 X 진짜 인스턴스
지연 로딩일 때!
select쿼리를 보면 team이 조회되지 않지만 team을 가져올 때 프록시가 가져와짐.
즉시 로딩일 때!!
member로딩할때 team까지 조인해서 가지고 옴.
프록시와 즉시로딩 주의
- 가급적 지연 로딩만 사용해야 한다.
- 즉시 로딩을 적용하면 예상하지 못한 SQL이 발생한다. (컬럼이 많으면 select 문에 매우 길어짐. )
- 즉시 로딩은 JPQL에서 N+1 문제를 일으킨다.
- @ManyToOne, @OneToOne은 기본이 즉시 로딩
- @OneToMany, @ManyToMany는 기본이 지연 로딩
영속성 전이 : CASECADE
@OneToMany(mappedBy = "parent", cascade = CascadeType.ALL)
private List<Child> childList = new ArrayList<>();try {
Child child1 = new Child();
Child child2 = new Child();
Parent parent = new Parent();
parent.addChild(child1);
parent.addChild(child2);
em.persist(parent);
tx.commit();
} catch (Exception e) {
tx.rollback();
} finally {
em.close();
}parent만 persist해도 child가 insert된다.
영속성 전이 - 주의
- 영속성 전이는 연관관계를 매핑하는 것과 아무 관련없음.
- 엔티티를 영속화할때 연관된 엔티티도 함께 영속화 하는 편리함을 제공할뿐임.
고아 객체
Parent findParent = em.find(Parent.class, parent.getId());
findParent.getChildList().remove(0);고아 객체 제거 : 부모 엔티티와 연관관계가 끊어진 자식 엔티티를 자동으로 삭제
delete hellojpa.Child */ delete
from
Child
where
id=?
@OneToMany(mappedBy = "parent", orphanRemoval = true)
private List<Child> childList = new ArrayList<>();
- 참조가 제거된 엔티티는 다른 곳에서 참조하지 않는 고아 객체로 보고 삭제하는 기능
- 참조하는 곳이 하나일때 사용해야함!
- 특정 엔티티가 개인 소유할 때 사용
- @OneToOne, @OneToMany만 가능
- 개념적으로 부모를 제거하면 자식은 고아가 된다. 따라서 고아 객체 제거 기능을 활성화 하면, 부모를 제거할 때 자식도 함께 제거된다. Casecade.Type.REMOVE처럼 동작한다.
값 타입
JPA의 데이터 타입 분류
- 엔티티 타입
- @Entity로 정의하는 객체
- 데이터가 변해도 식별자로 지속해서 추적 기능
- 회원 엔티티의 키나 나이 값을 변경해도 식별자로 인식 가능
- 값 타입
- int, Integer, String처럼 단순히 값으로 사용하는 자바 기본 타입이나 객체
- 식별자가 없고 값만 있으므로 변경시 추적 불가
- 숫자 100을 200으로 변경하면 완전히 다른 값으로 대체
값 타입 분류
기본 값 타입
- 자바 기본 타입(int, double)
- 래퍼 클래스(Integer, Long)
- String
임베디드 타입(embedded type, 복합 값 타입)
컬렉션 값 타입(collection value type)
기본 값 타입
- 예 String name, int age
- 생명주기를 엔티티의 의존
- 회원을 삭제하면 이름, 나이 필드도 함께 삭제
- 값 타입은 절대 공유하면 안됨.
- 회원 이름 변경시 다른 회원의 이름도 함께 변경되면 안됨.
- int, double같은 기본 타입은 절대 공유하면 안됨.
- 기본 타입은 항상 값을 복사한다.
- Integer같은 래퍼 클래스나 String같은 특수한 클래스는 공유 가능한 객체이지만 변경할 수 없다.
public class ValueMain {
public static void main(String[] args) {
int a = 10;
int b = a;
a = 20;
}
}a의 값을 20으로 변경하면 a는 20이지만 b는 여전히 10이다.
임베디드 타입(복합 값 타입)
- 새로운 값 타입을 직접 정의할 수 있음
- JPA는 임베디드 타입이라 함.
- 주로 기본 값 타입을 모아서 만들어서 복합 값 타입이라고도 함.
- int, String과 같은 값 타입
Member.java
@Entity
public class Member{
@Id @GeneratedValue
@Column(name = "MEMBER_ID")
private Long id;
@Column(name = "USERNAME")
private String name;
//Period
@Embedded
private Period workPeriod;
//주소
@Embedded
private Address homeAddress;
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Period getWorkPeriod() {
return workPeriod;
}
public void setWorkPeriod(Period workPeriod) {
this.workPeriod = workPeriod;
}
public Address getHomeAddress() {
return homeAddress;
}
public void setHomeAddress(Address homeAddress) {
this.homeAddress = homeAddress;
}
}
Address.java
@Embeddable
public class Address {
//주소
private String city;
private String street;
private String zipcode;
public Address() {
}
public Address(String city, String street, String zipcode) {
this.city = city;
this.street = street;
this.zipcode = zipcode;
}
public String getCity() {
return city;
}
public void setCity(String city) {
this.city = city;
}
public String getStreet() {
return street;
}
public void setStreet(String street) {
this.street = street;
}
public String getZipcode() {
return zipcode;
}
public void setZipcode(String zipcode) {
this.zipcode = zipcode;
}
}
Period.java
@Embeddable
public class Period {
private LocalDateTime startDate;
private LocalDateTime endDate;
public LocalDateTime getStartDate() {
return startDate;
}
public void setStartDate(LocalDateTime startDate) {
this.startDate = startDate;
}
public LocalDateTime getEndDate() {
return endDate;
}
public void setEndDate(LocalDateTime endDate) {
this.endDate = endDate;
}
}
member추가.
tx.begin();
try {
Member member = new Member();
member.setName("hello");
member.setHomeAddress(new Address("city", "street", "zipcode"));
member.setWorkPeriod(new Period());
em.persist(member);
tx.commit();SELECT * FROM MEMBER ;
MEMBER_ID CITY STREET ZIPCODE USERNAME ENDDATE STARTDATE
| 1 | city | street | zipcode | hello | null | null |
임베디드 타입과 테이블 매핑
- 임베디드 타입은 엔티티의 값일 뿐이다.
- 임베디드 타입을 사용하기 전과 후에 매핑하는 테이블은 같다.
- 객체와 테이블을 아주 세밀하게 매핑하는것이 가능하다.
- 잘 설계한 ORM애플리케이션은 매핑한 테이블의 수보다 클래스의 수가 더 많음.
값 타입과 불변 객체
값 타입은 복잡한 객체 세상을 조금이라도 단순화 하려고 만든 개념이다. 따라서 값 타입은 단순하고 안전하게 다룰 수 있어야 한다.
- 임베디드 타입 같은 값 타입을 여러 엔티티에서 공유하면 위험하다.
- 대신 값을 복사해서 사용한다.
try {
Address address = new Address("city", "street", "zipcode");
Member member = new Member();
member.setName("member1");
member.setHomeAddress(address);
em.persist(member);
Address copyAddress = new Address(address.getCity(), address.getStreet(), address.getZipcode());
Member member2 = new Member();
member2.setName("member2");
member2.setHomeAddress(copyAddress);
em.persist(member2);
member.getHomeAddress().setCity("newCity");
tx.commit();
} catch (Exception e) {
tx.rollback();
} finally {
em.close();
}address를 두 member에 넣는게 아니라 member2에는 복사한 address를 넣어야 함. 그렇지 않으면 두개의 city가 동시에 바뀜. 객체타입은 참조를 전달하기 때문에.
객체 타입의 한계
- 항상 값을 복사해서 사용하면 공유 참조로 인해 발생하는 부작용을 피할 수 있다.
- 문제는 임베디드 타입처럼 직접 정의한 값 타입은 자바의 기본 타입이 아니라 객체 타입이다.
- 자바 기본 타입에 값을 대입하면 값을 복사한다.
- 객체 타입은 참조 값을 직접 대입하는 것을 막을 방법이 없다.
- 객체의 공유 참조는 피할 수 없다.
기본 타입(primitive type)
int a = 10;
int b = a;//기본 타입은 값을 복사
b = 4;
객체 타입
Address a = new Address(“Old”);
Address b = a; //객체 타입은 참조를 전달
b. setCity(“New”)
불변 객체
- 객체 타입은 수정할 수 없게 만들면 부작용을 원천 차단
- 값 타입은 불변 객체로 설계해야 함.
- 불변객체 : 생성 시점 이후 절대 값을 변경할 수 없는 객체
- 생성자로만 값을 설정하고, 수정자(Setter)를 만들지 않으면 된다.
- Integer, String은 자바가 제공하는 대표적인 불변 객체.
값 타입의 비교
값 타입 : 인스턴스가 달라도 그 안에 값이 같으면 같은 것으로 봐야 함.
동일성 비교 : 인스턴스의 참조 값을 비교, ==사용
동등성 비교 : 인스턴스의 값을 비교, equals()사용 ==> equals는 적절히 오버라이딩해서 사용해야 함.
값 타입 컬렉션
@Entity
public class Member{
@Id @GeneratedValue
@Column(name = "MEMBER_ID")
private Long id;
@Column(name = "USERNAME")
private String name;
//Period
@Embedded
private Period workPeriod;
//주소
@Embedded
private Address homeAddress;
@ElementCollection
@CollectionTable(name = "FAVORITE_FOOD", joinColumns =
@JoinColumn(name = "MEMBER_ID")
)
@Column(name = "FOOD_NAME")
private Set<String> favoriteFoods = new HashSet<>();
@ElementCollection
@CollectionTable(name = "ADDRESS", joinColumns =
@JoinColumn(name = "MEMBER_ID")
)
private List<Address> addressHistory = new ArrayList<>();
- 값 타입을 하나 이상 저장할 때 사용
- @ElementCollection, @CollectionTable사용
- 데이터베이스는 컬렉션을 같은 테이블에 저장할 수 없다. (디비안에 컬렉션은 못 넣음)
- 컬렉션을 저장하기 위한 별도의 테이블이 필요함. (디비에는 테이블을 별도로 만들어야 함.)
try {
Member member = new Member();
member.setName("member1");
member.setHomeAddress(new Address("homeCity", "street", "10000"));
member.getFavoriteFoods().add("치킨");
member.getFavoriteFoods().add("족발");
member.getFavoriteFoods().add("피자");
member.getAddressHistory().add(new Address("old1", "street", "10000"));
member.getAddressHistory().add(new Address("old2", "street", "10000"));
em.persist(member);
em.flush();
em.clear();
System.out.println("==============START===============");
Member findMember = em.find(Member.class, member.getId());
tx.commit();
} catch (Exception e) {
tx.rollback();
} finally {
em.close();
}쿼리 실행 :
Hibernate:
call next value for hibernate_sequence
Hibernate:
/* insert hellojpa.Member
*/ insert
into
Member
(city, street, zipcode, USERNAME, endDate, startDate, MEMBER_ID)
values
(?, ?, ?, ?, ?, ?, ?)
Hibernate:
/* insert collection
row hellojpa.Member.addressHistory */ insert
into
ADDRESS
(MEMBER_ID, city, street, zipcode)
values
(?, ?, ?, ?)
Hibernate:
/* insert collection
row hellojpa.Member.addressHistory */ insert
into
ADDRESS
(MEMBER_ID, city, street, zipcode)
values
(?, ?, ?, ?)
Hibernate:
/* insert collection
row hellojpa.Member.favoriteFoods */ insert
into
FAVORITE_FOOD
(MEMBER_ID, FOOD_NAME)
values
(?, ?)
Hibernate:
/* insert collection
row hellojpa.Member.favoriteFoods */ insert
into
FAVORITE_FOOD
(MEMBER_ID, FOOD_NAME)
values
(?, ?)
Hibernate:
/* insert collection
row hellojpa.Member.favoriteFoods */ insert
into
FAVORITE_FOOD
(MEMBER_ID, FOOD_NAME)
values
(?, ?)
==============START===============
Hibernate:
select
member0_.MEMBER_ID as MEMBER_I1_6_0_,
member0_.city as city2_6_0_,
member0_.street as street3_6_0_,
member0_.zipcode as zipcode4_6_0_,
member0_.USERNAME as USERNAME5_6_0_,
member0_.endDate as endDate6_6_0_,
member0_.startDate as startDat7_6_0_
from
Member member0_
where
member0_.MEMBER_ID=?
select 쿼리에는 Address정보도 함께 조회된다. 값 타입 컬렉션도 지연 로딩 전략을 사용한다.
em.flush();
em.clear();
System.out.println("==============START===============");
Member findMember = em.find(Member.class, member.getId());
//homeCity -> newCity
// findMember.getHomeAddress().setCity("newCity");
Address a = findMember.getHomeAddress();
findMember.setHomeAddress(new Address("newCity",a.getStreet(), a.getStreet()));만약 값 타입을 변경할 경우 set으로 변경하면 안되고 , 새롭게 주소를 넣어야 한다.
System.out.println("==============START===============");
Member findMember = em.find(Member.class, member.getId());
//homeCity -> newCity
// findMember.getHomeAddress().setCity("newCity");
Address a = findMember.getHomeAddress();
findMember.setHomeAddress(new Address("newCity",a.getStreet(), a.getStreet()));
//치킨 -> 한식
findMember.getFavoriteFoods().remove("치킨");
findMember.getFavoriteFoods().add("한식");
주소는 새롭게 넣지만 FavoriteFood는 컬렉션처럼 삭제하고 새로 추가해야한다. 그럼 delete쿼리가 나가고 다시 insert된다.
값 타입은 엔티티와 다르게 식별자 개념이 없다.
값은 변경하면 추적이 어렵다.
값 타입 컬렉션에 변경 사항이 발생하면, 주인엔티티와 연관된 모든 데이터를 삭제하고, 값 타입 컬렉션에 있는 현재 값을 모두 다시 저장한다.
값 타입 컬렉션을 매핑하는 테이블은 모든 컬럼을 묶어서 기본키를 구성해야 한다. null을 입력하면 안되고, 중복 저장할 수 없다,.
'jpa' 카테고리의 다른 글
| 객체지향 쿼리 언어 JPQL (0) | 2022.04.02 |
|---|---|
| [Transaction Isolation]과 트랜잭션 범위의 영속성 컨텍스트 (0) | 2022.04.02 |
| 엔티티 매핑 (0) | 2022.03.19 |
| JPA소개와 작동 매커니즘 (0) | 2022.03.17 |
블로그의 정보
kiwi
키위먹고싶다