[JPA][개념] 값 타입

값 타입이란?

JPA는 데이터 타입을 크게 두 가지로 분류함. 
1.Entity type
2.Value type

Value 타입은 값의 변경을 추적할 수 없는 타입을 말합니다. int, double와 같은 Primitive 타입뿐만 아니라, Integer, String과 같은 클래스도 참조는 가지지만 값의 변경을 추적할 수 없기 때문에 마찬가지로 Value 타입에 속합니다. (값의 변경을 추적할 수 없다는 말은 값을 변경할 수 없다는 의미입니다. Integer, String의 값을 변경하면 참조하는 주소가 바뀝니다.)
int, Integer, String 등 단순히 값으로 사용하는 자바 기본 타입이나 객체
식별자가 없고 값만 존재하기 때문에 추적이 변경시 불가능
생명주기를 엔티티에 의존.
의존하는 엔티티가 제거되면 함께 삭제
공유하지 않는 것이 안전


JPA의 Value 타입은 세 가지로 나눠 생각해볼 수 있습니다.
1.기본 값 타입: int, double와 같은 Java의 Primitive 타입과, Integer, String과 같은 래퍼 클래스를 말합니다.
2.Embedded 타입 (복합 값 타입): 기본 값 타입을 래핑해서 새롭게 만든 클래스 타입을 말합니다.
3.Collection 값 타입: 위 1, 2번 타입을 List, Set과 같은 Collection 형태로 사용하는 것을 말합니다.

 

 

 

임베디드 타입

임베디드 타입 사용법
•@Embeddable: 값 타입을 정의 하는 곳에 표시
•@Embedded: 값 타입을 사용 하는 곳에 표시
•기본생성자필수

 

임베디드타입과 테이블매핑 
•임베디드타입은 엔티티의 값일 뿐이다. 
•임베디드타입을 사용하기 전과 후에 매핑하는 테이블은 같다. 
•객체와 테이블을 아주 세밀하게(find-grained) 매핑하는 것이 가능 
•잘 설계한 ORM 애플리케이션은 매핑한 테이블의 수보다 클래스의 수가 더 많음

 

임베디드 타입과 연관관계

 

@AttributeOverride: 속성 재정의 
•한 엔티티에서 같은 값타입을 사용하면? 
•컬럼명이 중복됨 
•@AttributeOverrides, @AttributeOverride 를 사용해서 컬럼명 속성을 재정의

 

@Entity
public class Member {

    @Id
    @GeneratedValue
    @Column(name = "MEMBER_ID")
    private Long id;

    @Column(name = "USERNAME")
    private String username;

    //기간 Period
    @Embedded
    private Period workPeriod;

    //주소
    @Embedded
    private Address homeAddress;

    //주소2
    @Embedded
    @AttributeOverrides({
            @AttributeOverride(name="city",
                    column = @Column(name = "WORK_CITY")),
            @AttributeOverride(name="street",
                    column = @Column(name = "WORK_STREET")),
            @AttributeOverride(name="zipcode",
                    column = @Column(name = "WORK_ZIPCODE"))
    })
    private Address workAddress;


}

 

@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;
    }
}

    create table Member (
       MEMBER_ID bigint not null,
        city varchar(255),
        street varchar(255),
        zipcode varchar(255),
        USERNAME varchar(255),
        WORK_CITY varchar(255),
        WORK_STREET varchar(255),
        WORK_ZIPCODE varchar(255),
        endDate timestamp,
        startDate timestamp,
        TEAM_ID bigint,
        primary key (MEMBER_ID)
    )

값 타입이란?

 

 

값 타입을 사용하는 이유는?

 

임베디드 타입

임베디드 타입 사용법
•@Embeddable: 값 타입을 정의 하는 곳에 표시
•@Embedded: 값 타입을 사용 하는 곳에 표시
•기본생성자필수

 

임베디드타입과 테이블매핑 
•임베디드타입은 엔티티의 값일 뿐이다. 
•임베디드타입을 사용하기 전과 후에 매핑하는 테이블은 같다. 
•객체와 테이블을 아주 세밀하게(find-grained) 매핑하는 것이 가능 
•잘 설계한 ORM 애플리케이션은 매핑한 테이블의 수보다 클래스의 수가 더 많음

 

임베디드 타입과 연관관계

 

@AttributeOverride: 속성 재정의 
•한 엔티티에서 같은 값타입을 사용하면? 
•컬럼명이 중복됨 
•@AttributeOverrides, @AttributeOverride 를 사용해서 컬럼명 속성을 재정의

 

@Entity
public class Member {

    @Id
    @GeneratedValue
    @Column(name = "MEMBER_ID")
    private Long id;

    @Column(name = "USERNAME")
    private String username;

    //기간 Period
    @Embedded
    private Period workPeriod;

    //주소
    @Embedded
    private Address homeAddress;

    //주소2
    @Embedded
    @AttributeOverrides({
            @AttributeOverride(name="city",
                    column = @Column(name = "WORK_CITY")),
            @AttributeOverride(name="street",
                    column = @Column(name = "WORK_STREET")),
            @AttributeOverride(name="zipcode",
                    column = @Column(name = "WORK_ZIPCODE"))
    })
    private Address workAddress;


}

@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;
    }
}

    create table Member (
       MEMBER_ID bigint not null,
        city varchar(255),
        street varchar(255),
        zipcode varchar(255),
        USERNAME varchar(255),
        WORK_CITY varchar(255),
        WORK_STREET varchar(255),
        WORK_ZIPCODE varchar(255),
        endDate timestamp,
        startDate timestamp,
        TEAM_ID bigint,
        primary key (MEMBER_ID)
    )

 

 

값 타입과 불변 객체 

*값 타입의 실제 인스턴스인 값을 공유하는 것은 위험하다. 대신 값(인스턴스)를 복사해서 사용 

//before
            Address address = new Address("city", "street", "10000");

            Member member = new Member();
            member.setUsername("member1");
            member.setHomeAddress(address);
            em.persist(member);

            Member member2 = new Member();
            member2.setUsername("member2");
            member2.setHomeAddress(address);
            em.persist(member2);

            member.getHomeAddress().setCity("newCity");
            
//after
       Address address = new Address("city", "street", "10000");

            Member member = new Member();
            member.setUsername("member1");
            member.setHomeAddress(address);
            em.persist(member);

            Address copyAddress =  new Address(address.getCity(),address.getStreet(), address.getZipcode());

            Member member2 = new Member();
            member2.setUsername("member2");
            member2.setHomeAddress(copyAddress);
            em.persist(member2);

            member.getHomeAddress().setCity("newCity");

 

객체 타입의 한계

객체 타입에서 결국 떠 있는 인스터는 하나이다. 

해결책은?

값타입은 불변객체(immutable object)로 설계해야 함( 생성시점 이후 절대 값을 변경할 수 없는 객체) 

생성자로만 값을 설정하고 수정자(setter)를 만들지 않으면 됨(Integer, String은 자바가 제공하는 대표적인 불변 객체임)

또는 setter를 private으로 설정하는 방법(내부적 용도로만)

실제로 값을 변경하고 싶다면? 새로운 인스턴스 만들어서 통째로 바꿔줘야 한다. 

 

값 타입 비교 

인스턴스가 달라도 그 안에 값이 같으면 같은 것으로 봐야 한다. 

값 타입은 인스턴스의 참조 값 비교인 동일성(identity)비교가 아니라 동등성(equivalence)비교인 인스턴스의 값을 비교해야 함.

값 타입은 a.equals(b) 를 사용해서 동등 성비교를 해야 함

package hellojpa;

import javax.persistence.Embeddable;
import java.util.Objects;

@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 String getStreet() { return street; }

    public String getZipcode() {return zipcode; }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Address address = (Address) o;
        return Objects.equals(city, address.city) && Objects.equals(street, address.street) && Objects.equals(zipcode, address.zipcode);
    }

    @Override
    public int hashCode() {
        return Objects.hash(city, street, zipcode);
    }
}

 

값 타입 컬렉션 

 

 

값 타입 컬렉션의 제약 사항 

값 타입은 엔티티와 다르게 식별자 개념이 없다.

값은 변경하면 추적이 어렵다.

값 타입 컬렉션에 변경 사항이 발생하면, 주인 엔티티와 연관된 모든 데이터를 삭제하고, 값 타입 컬렉션에 있는 현재 값을 모두 다시 저장한다. 

값 타입 컬렉션을 매핑하는 테이블은 모든 컬럼을 묶어서 기본키를 구성해야 함(null 입력 x, 중복 저장 x)

실무에서는 값타입 컬렉션 대신 일대다 관계를 고려

일대다 관계를 위한 엔티티를 만들고, 여기에서 값 타입을 사용(값 타입을 엔티티로 승급한다)

 

값 타입 컬렉션 
//Member 
@ElementCollection
    @CollectionTable(name = "ADDRESS", joinColumns =
        @JoinColumn(name = "MEMBER_ID")
    )
    private List<Address> addressHistory = new ArrayList<>();
    

//Address 
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;
    }
    
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Address address = (Address) o;
        return Objects.equals(city, address.city) && Objects.equals(street, address.street) && Objects.equals(zipcode, address.zipcode);
    }

    @Override
    public int hashCode() {
        return Objects.hash(city, street, zipcode);
    }
}

//값 타입의 변경, 조회 
            값타입 값 타입의 변경 조회 
            Address a = findMemeber.getHomeAddress();
            findMemeber.setHomeAddress(new Address("newCity",a.getStreet(), a.getZipcode()));

            값타입 컬렉션 변경
            치킨 -> 한식
            findMemeber.getFavoriteFoods().remove("치킨");
            findMemeber.getFavoriteFoods().add("한식");

            주소 변경
            findMemeber.getAddressHistory().remove(new Address("old1", "street", "10111"));
            findMemeber.getAddressHistory().add(new Address("newCity1", "street", "10111"));



            값타입 조회
            List<Address> addressHistory = findMemeber.getAddressHistory();
            for (Address address : addressHistory) {
                System.out.println("address = " + address.getCity());
            }

            Set<String> favoriteFoods = findMemeber.getFavoriteFoods();
            for (String favoriteFood : favoriteFoods) {
                System.out.println("favoriteFood = " + favoriteFood );
            }

대안 값 타입을 엔티티로 승격 

AddressEntity 클래스 생성 

@Entity
@Table(name = "ADDRESS")
public class AddressEntity {
    @Id
    @GeneratedValue
    private Long Id;

    private Address address;

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

    public AddressEntity(Address address) {
        this.address = address;
    }

}

//Member Class 
@Entity
public class Member {
    @OneToMany(cascade = CascadeType.ALL, orphanRemoval = true)
    @JoinColumn(name = "MEMBER_ID")
    private List<AddressEntity> addressHistory = new ArrayList<>();
}

•엔티티 타입의 특징
•식별자 O 
•생명 주기 관리
•공유

•값 타입의 특징
•식별자X 
•생명주기를 엔티티 에의존
•공유하지 않는 것이 안전 (복사해서사용) 
•불변 객체로 만드는 것 이안전

 

 

<<예제>>

 

기존 Member에 있던 값들을 Address라는 값타입으로 생성 

 

@Entity
public class Member  extends  BaseEntity{

    @Embedded
    private Address address;

}

package jpabook.jpashop.domain;

import javax.persistence.Embeddable;
import javax.persistence.Embedded;
import java.util.Objects;

@Embeddable
public class Address {

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

    public String getCity() {
        return city;
    }

    private void setCity(String city) {
        this.city = city;
    }

    public String getStreet() {
        return street;
    }

    private void setStreet(String street) {
        this.street = street;
    }

    public String getZipcode() {
        return zipcode;
    }

    private void setZipcode(String zipcode) {
        this.zipcode = zipcode;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Address address = (Address) o;
        return Objects.equals(getCity(), address.getCity()) &&
                Objects.equals(getStreet(), address.getStreet()) &&
                Objects.equals(getZipcode(), address.getZipcode());
    }

    @Override
    public int hashCode() {
        return Objects.hash(getCity(), getStreet(), getZipcode());
    }
}

 

 

 

<<참조>>

https://pangtrue.tistory.com/346