[JPA] 값 타입 - 임베디드 값 타입, 컬렉션 값 타입

JPA의 데이터 타입에는 크게 엔티티 타입, 값 타입으로 나눌 수 있습니다.

// 엔티티 타입 
@Entity
public class Member{

    @Id 
    private Long id; // 값 타입

    private String name; // 값 타입

    @Embedded
    private Address address; // 임베디드 값 타입

    private List<Address> addressHistory; // 컬렉션 값 타입 

}

• 엔티티 타입 : 단순히 @Entity로 정의하는 객체
• 값 타입 : 단순한 수치 정보
  • 단순 값 타입 : int, double, String, Integer 
  • 임베디드 값 타입 : 사용자 정의 타입 @Embedded
  • 컬렉션 값 타입 : List, Set, Map 과 같은 컬렉션을 사용한 타입 

값 타입 특징

• 엔티티 타입은 식별자 값을 통해 추적이 가능하다는 점에 반해, 값 타입은 단순한 수치정보이기 때문에 식별자로 추적이 불가능합니다.
• 생명주기를 엔티티에 의존합니다. 즉, 엔티티가 삭제되면 값타입은 자동으로 같이 제거됩니다.
  • 엔티티는 생성, 영속화, 소멸하는 생명주기가 있습니다.

---

임베디드 값 타입 ( 복합 값 타입)

새로운 값 타입을 직접 정의해서 사용하는 타입입니다. 임베디드 타입도 마찬가지로 값 타입을 포함하고 있습니다.

@Embeddable
public class Address {

	private String city; // 값 타입
	private String street; // 값 타입
    ...
}

Member 엔티티에 city, street으로 상세 데이터를 갖는 것보다 임베디드 타입을 사용해서 정의하는 것이 가독성이나, 객체지향 측면에서 좋습니다.

뿐만 아니라 새로 정의한 값 타입인 Address는 클래스이기 때문에 재사용도 가능하고, 응집도도 아주 높습니다.

임베디드 값 타입은 기본 생성자가 필수적으로 있어야 합니다.

 임베디드 값 타입은 값 타입을 포함할 뿐만 아니라 엔티티를 참고하는 것도 가능합니다.

@Embeddable
public class Address {

    private String city; // 값 타입
    private String street; // 값 타입
    ...

    @Embedded
    private ZipCode zipcode; // 임베디드 타입 포함

    @ManyToOne
    private State state; // 엔티티 참조 
}

+ @AttributeOverride를 사용해 매핑 정보를 재정의 할 수 있습니다.

@Entity
public class Member{

    @Id @GeneratedValue
    private Long id;

    private String name;

    @Embedded
    private Address address;

    @Embedded
    @AttributeOverrides({ 
    @AttributeOverride(name="city", column=@Column(name="COMPANY_CITY")),
    @AttributeOverride(name="street", column=@Column(name="COMPANY_STREET")),
    @AttributeOverride(name="zipcode", column=@Column(name="COMPANY_ZIPCODE"))})
    private Address companyAddress;

}

• 매핑정보를 재정의하는 경우는 드물긴 합니다만, 임베디드 타입을 한 엔티티에서 재사용하는 경우 @AttributeOverride로 매핑정보(컬럼명)을 재정의 할 수 있습니다.

+ 임베디드 타입을 null로 설정하면 타입 내부 모든 값 타입이 null로 설정됩니다.

member.setAddress(null);
em.persist(member);
// -> member.address.city = null
// -> member.address.street = null
// -> member.address.zipcode = null

임베디드 값 타입 사용시 주의할 점

임베디드 값 타입 사용 시 주의해야 할 점이 있습니다.

1. 값 타입은 공유되어서는 안됩니다.

• 회원1.address.city = "OldCity" 
• add = 회원1.getAddress()
• 회원2.setAddress(add) 
• 회원2.address.city = "NewCity"
• 회원1의 city도 NewCity로 변경됨 ( 공유 참조 부작용 )

임베디드 값 타입도 객체이기 때문에 공유되게 되면 자바에서는 인스턴스 값을 공유하는 것이 아니라 참조를 공유하게 됩니다. 

 

참조를 공유하게 되면 임베디드 타입 내부 값이 변경되면 해당 인스턴스를 공유해서 사용하는 엔티티들의 값이 전부 Update 되는 부작용이 발생합니다.

 

공유 참조로 발생하는 버그는 정말 찾아내기 어렵기 때문에, 임베디드 타입의 인스턴스는 공유해서 사용하지 않도록 합시다.

 

단편적인 해결방법 : 공유하는 대신 인스턴스를 복사해서 사용하는 방법이 있습니다.

자바는 기본 값 타입은 값을 복사해서 넘기지만, 객체 타입은 참조만 넘깁니다.

하지만 별도의 메소드로 해당 객체 타입이 참조가 아닌 인스턴스의 값을 넘기도록 구현해서 복사할 수 있습니다.

member.setAddress(new Address("전주", "금암동", "명륜1길");
Address address = member.getAddress();

Address address2 = address.clone(); // clone() 메소드에 참조가 아닌 인스턴스의 값을 복사하도록 구현 

address.setZipcode("명륜2길");
member2.setAddress(address2);

 

하지만 이것이 공유 참조를 막는 근본적인 해결책은 아니죠. 공유 참조를 막으려면 근본적으로 객체를 불변하게 해야합니다.

 

근본적인 해결방법 : 수정자 메소드 제거.

@Embedded
public class Address{

    private String city;
    private String street;
    private String zipcode;

    public Address(String city,String street,String zipcode)
    {
        this.city = city;
        this.street = street;
        this.zipcode = zipcode;
    }

	// setter X
}

객체를 불변하게 한다.. 객체를 불변하게 하려면 한 번 생성된 객체의 수정을 막으면 됩니다.

쉽게 말해서, 기본 생성자만 만들고 setter는 사용하지 않는 것이죠.

 

객체를 불변하게 만들면 값을 수정할 수 없으므로 부작용을 원천에 차단할 수 있습니다. 따라서 값 타입은 가능한 불변객체로 설계하도록 합시다.

 

2. 임베디드 값 타입 비교 시 equals와 hashCode 메소드를 재정의 해주어야 합니다.

임베디드 값 타입은 결국 객체입니다.

자바에서는 기본 값 타입에 대해서 비교할 때, 동등성을 비교하고, 객체 타입에 대해 비교할 때는 동등성을 비교합니다.

 

여기서 동일성이란 인스턴스의 값을 비교한다는 것이고, 동등성은 인스턴스의 참조 값을 비교한다는 뜻입니다.

 

일반적으로 우리는 두 값을 비교할 때 참조값을 비교하는 것이 아니라, 인스턴스가 내포하고 있는 값 그 자체를 비교합니다. 하지만 자바는 객체에 대해서는 기본적으로 동등성을 비교한다고 했습니다.

 

따라서 우리가 두 임베디드 값 타입을 비교할 때 동등성이 아닌 동일성을 기준으로 비교하고 싶다고 하면 equals, hashCode 메소드를 재정의해 줌으로써, 모든 필드의 값을 비교하도록 구현해서 동일성을 비교하도록 설정해주어야 합니다. 

 

How to Override

동일성과 동등성 (feat. equals와 hashCode)

 

---

값 타입 컬렉션 

값 타입을 하나이상 저장할 때 컬렉션에 보관하여 컬렉션을 값 타입처럼 사용할 수 있습니다.

이 때 @ElementCollection , @CollectionTable 어노테이션이 사용됩니다.

@Entity
public class Member {

    @Id
    private Long id;

    private String name;

    @Embedded // 임베디드 값 타입
    private Address address;

    @ElementCollection
    @CollectionTable(name = "ADDRESS",
                    joinColumns = @JoinColumn(name = "MEMBER_ID"))
    @Column(name="HISTORY_HOME")
    private List<Address> addressHistory = new ArrayList<Address>();

    ...

}

• @ElementCollection : 컬렉션 값 타입 매핑을 위해 사용되는 어노테이션
• 컬렉션은 T을 컬렉션으로 가지기 때문에 별도의 테이블을 추가하고 테이블을 매핑해야 합니다.
  • @CollectionTable : 컬렉션 값 타입을 테이블과 매핑해주는 어노테이션으로 이 어노테이션을 통해 컬렉션과 테이블을 매핑할 수 있습니다. ( 이 어노테이션 생략 시 기본값(엔티티이름_컬렉션 속성이름)으로 설정된 테이블과 자동 매핑합니다. )

값 타입 컬렉션 저장 시 영속성 전이 + 고아 객체 제거 기능은 자동으로 가지고 있습니다.

엔티티를 영속화 해봅시다.

@Entity
public class Member {

    @Id
    private Long id;

    private String name;

    @Embedded // 임베디드 값 타입
    private Address address;

    @ElementCollection
    @CollectionTable(name = "ADDRESS",
                    joinColumns = @JoinColumn(name = "MEMBER_ID"))
    @Column(name="HISTORY_HOME")
    private List<Address> addressHistory = new ArrayList<Address>();

    ...

}

member.setName("kim");
member.setAddress(new Address("전주","금암","명륜1"));
member.getAddressHistory().add(new Address("전주","객사","82")); 
em.persist(member);

persist 호출 후 commit하여 flush하게 되면 2번의 SQL이 실행됩니다.

insert into MEMBER (id, name, city, street, zipcode) values(1, 'kim', '전주', '금암', '명륜1');
insert into ADDRESS (id, city, street, zipcode) values(1,'전주', '객사', '82');

JPA는 값 타입도 함께 영속화 하기 때문에 값 타입 컬렉션과 매핑된 테이블에도 insert sql이 실행됩니다.

 

+  값 타입 컬렉션을 조회할 때도 당연히 패치 전략을 사용할 수 있는데 JPA는 기본적으로 값 타입 컬렉션을 지연로딩(LAZY)로 설정해 두었습니다.

Member member = em.find(Member.class, 1L);

List<Address> addressHistory = member.getAddressHistory();

addressHistory.get(0); // 실제 사용 시 호출하는 LAZY 전략이 기본 적용.

값 타입 컬렉션은 기본적으로 지연로딩으로 설정되어 있기 때문에, 실제 컬렉션을 사용할 때 SELECT SQL을 1번 호출합니다.

 

+ 값 타입 컬렉션은 컬렉션에 변경 사항 발생 시 연관된 모든 데이터를 삭제하고, 변경 사항으로 다시 저장합니다.

값 타입 컬렉션에 보관된 값 타입들은 별도의 테이블에 보관됩니다.

 

따라서 여기에 보관된 값 타입의 값이 변경되면 데이터베이스에 있는 원본 데이터를 찾기 어렵다는 문제가 있습니다.

 

JPA는 이 문제를 해결하기 위해 값 타입 컬렉션의 변경사항이 생기면, 값 타입 컬렉션과 매핑된 테이블의 모든 데이터를 삭제하고, 현재 값 타입 컬렉션 객체에 있는 모든 값을 데이터베이스에 저장합니다.

Memberm member = em.find(Member.class, 100L); 
List<Address> addressHistory = member.getAddressHistory(); 
addressHistory.add(new Address('전주','집1','길1'));
addressHistory.add(new Address('전주','집2','길2'));
em.persist(member);

// commit 후 실행되는 SQL
select from member where member_id = 100


// 기존의 모든 데이터를 삭제
delete from address where member_id = 100


// 다시 저장 
insert into address (member_id, city, street, zipcode) values(100L, ...)
insert into address (member_id, city, street, zipcode) values(100L, ...)

 

따라서 실무에서는 값 타입 컬렉션이 매핑된 테이블에 데이터가 많다면 값 타입 컬렉션을 사용하는 것보다 엔티티 타입을 사용하여 일대다 관계로 매핑해주는 것이 좋습니다.

 

@Entity
public class Member {

    @Id
    private Long id;

    private String name;

    @Embedded // 임베디드 값 타입
    private Address address;
	
    
    // 영속성 전이, 고아 객체 제거 옵션 추가해서 값 타입 컬렉션처럼 매핑
    @OneToMany(cascade = CascadeType.ALL, orphanRemoval = true)
    @JoinColumn(name = "MEMBER_ID")
    private List<AddressHistory> addressHistory = new ArrayList<AddressHistory>();

    ...

}

@Entity
public class AddressHistory{

    @Id
    @GeneratedValue
    private Long id;

    @Embedded Address address;

}

 

<정리>

• 엔티티 타입은 식별자가 있어 추적이 가능하지만 값 타입은 식별자로 추적이 불가능합니다.
• 엔티티 타입은 참조 값을 공유하여 다른 엔티티에서 얼마든지 조회할 수 있지만, 값 타입은 공유하게 되면 참조 부작용 문제가 발생할 수 있기 때문에 불변 객체로 만드는 것이 좋습니다.
•  값 타입은 정말 값 타입이라 판단될 때만 사용합시다. 식별자가 필요해서 지속해서 값을 추적하고 구분하고 변경해야 한다면 엔티티 타입을 사용합시다.
• 값 타입 컬렉션은 @ElementCollection, @CollectionTable 어노테이션으로 사용하기보다, 값 타입 컬렉션을 일대다 매핑에 영속성 전이, 고아객체 삭제 옵션을 고려하는 것이 좋습니다.
  • why ? 값 타입 컬렉션에 변경사항이 발생하게 되면 값 타입 컬렉션에 매핑된 테이블의 연관된 모든 데이터를 삭제하고, 현재 값 타입 컬렉션 객체에 있는 모든 값을 데이터베이스에 다시 저장하기 때문에 매우매우 비효율적.

<참고 자료>

• 자바 ORM 표준 JPA 프로그래밍, 김영한