[JPA 기본] 값 타입

기본값 타입

JPA의 데이터 타입 분류

엔티티 타입
- @Entity로 정의하는 객체
- 데이터가 변해도 식별자로 지속해서 추적이 가능하다.
- 예시
  - 회원 엔티티의 키나 나이 값을 변경해도 식별자로 인식 가능
값 타입
- int, Integer, String처럼 단순히 값으로 사용하는 자바 기본 타입이나 객체
- 식별자가 없고 값만 있으므로 변경시 추적이 불가능하다.
- 예시
  - 숫자 100을 200으로 변경하면 완전히 다른 값으로 대체

값 타입 분류

기본값 타입
- 자바 기본 타입 (int, double 등…)
- 래퍼 클래스 (Integer, Long 등…)
- String
임베디드 타입(Embedded Type, 복합 값 타입)
컬렉션 값 타입(Collection Value Type)

기본값 타입

생명주기를 엔티티에 의존하는 타입
- 예시
  - 회원을 삭제하면 이름이나 나이 필드도 함께 삭제된다.
값 타입은 공유하면 안 된다.
- 사이드 이펙트가 발생한다.
- 예시
  - 회원 이름 변경시 다른 회원의 이름도 함께 변경되면 안 된다.
  - Java의 기본 타입은 절대 공유되지 않는다.
int, double 같은 기본 타입(primitive type)은 절대 공유되지 않는다.
- 그래서 값 타입으로 쓰기 안전하다.
기본 타입은 항상 값을 복사한다. (= 깊은 복사)
Integer같은 래퍼 클래스나 String 같은 특수한 클래스는 인스턴스를 공유 가능한 클래스이지만 값을 복사한다.

String a = "aaa";
String b = a;
a = "bbb";

System.out.println("a : " + a); //a : bbb
System.out.println("b : " + b); //b : aaa

임베디드 타입

직접 정의해서 사용하는 새로운 값 타입
JPA는 임베디드 타입(Embedded Type)이라고 부른다.
주로 기본 값 타입을 모아서 만드는 방식이기 때문에 복합 값 타입이라고도 부른다.
int, String과 같은 값 타입으로 취급한다.
임베디드 타입의 값이 null이면 매핑한 컬럼 값은 모두 null이 된다.
장점
- 재사용성
- 높은 응집도
- 해당 값 타입만 사용하는 의미 있는 메소드를 만들 수 있다.
- 임베디드 타입을 포함한 모든 값 타입은 값 타입을 소유한 엔티티에 생명주기를 의존한다.
관련 어노테이션
- @Embeddable
  - 값 타입을 정의하는 곳에 표시
  - 기본 생성자 필수
- @Embedded
  - 값 타입을 사용하는 곳에 표시
- @AttributeOverride or @AttributeOverrides
  - 하나의 엔티티가 동일한 값 타입을 사용하면 칼럼명이 겹치기 떄문에 각각의 컬럼명을 재정의할 때 사용한다.

임베디드 타입과 테이블 매핑

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

엔티티 정의

@Embeddable
@Getter //불변객체화 (setter 제거)
@NoArgsConstructor
@AllArgsConstructor
public class Address {
	private String city;
	private String street;
	private String zipcode;
}

@Embeddable
@Getter //불변객체화 (setter 제거)
@NoArgsConstructor
@AllArgsConstructor
public class Period {
	private LocalDateTime startDate;
	private LocalDateTime endDate;
	
	//의미있는 메소드 예시
	public boolean isWork() {
		boolean result = false;
		
		//예시 : 현재 날짜가 시작 기간과 종료 기간 사이면 true
		
		return result;
	}
}

//임베디드 타입을 한 번만 사용하는 경우
@Entity
@Data
public class Member {
	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	private Long id;
	
	private String name;
	
	@Embedded
	Period workPeriod; //기간

	@Embedded
	Address homeAddress; //자택 주소
}

//임베디드 타입을 여러 번 사용하는 경우
@Entity
@Data
public class Member {
	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	private Long id;
	
	private String name;
	
	@Embedded
	Period workPeriod; //기간
	
	@Embedded
	@AttributeOverrides(value = {
			@AttributeOverride(name="city", column=@Column(name = "home_city")),
			@AttributeOverride(name="street", column=@Column(name = "home_street")),
			@AttributeOverride(name="zipcode", column=@Column(name = "home_zipcode"))
	})
	Address homeAddress; //자택 주소
	
	@Embedded
	@AttributeOverrides(value = {
			@AttributeOverride(name="city", column=@Column(name = "work_city")),
			@AttributeOverride(name="street", column=@Column(name = "work_street")),
			@AttributeOverride(name="zipcode", column=@Column(name = "work_zipcode"))
	})
	Address workAddress; //직장 주소
}

생성된 테이블

/* 임베디드 타입을 한 번만 사용하는 경우 */
create table Member (
    id bigint not null auto_increment,
    city varchar(255),
    street varchar(255),
    zipcode varchar(255),
    name varchar(255),
    endDate datetime(6),
    startDate datetime(6),
    primary key (id)
) engine=InnoDB

/* 임베디드 타입을 여러 번 사용하는 경우 */
create table Member (
    id bigint not null auto_increment,
    home_city varchar(255),
    home_street varchar(255),
    home_zipcode varchar(255),
    name varchar(255),
    work_city varchar(255),
    work_street varchar(255),
    work_zipcode varchar(255),
    endDate datetime(6),
    startDate datetime(6),
    primary key (id)
) engine=InnoDB

테스트

Member member = new Member();
member.setName("user");
member.setHomeAddress(new Address("city", "street", "zipcode"));

em.persist(member);

tx.commit();

/* 임베디드 타입을 한 번만 사용하는 경우 */
insert 
into
    Member (city, street, zipcode, name, endDate, startDate) 
values
    (?, ?, ?, ?, ?, ?)

/* 임베디드 타입을 여러 번 사용하는 경우 */
insert 
into
    Member (home_city, home_street, home_zipcode, name, work_city, work_street, work_zipcode, endDate, startDate) 
values
    (?, ?, ?, ?, ?, ?, ?, ?, ?)

값 타입과 불변 객체

값 타입은 복잡한 객체 세상을 조금이라도 단순화하려고만든 개념이다.
값 타입은 단순하고 안전하게 다룰 수 있어야 한다

값 타입 공유 참조

임베디드 타입 같은 값 타입을 여러 엔티티에서 공유하면 위험하다.
부작용(Side Effect)이 발생한다.

값 타입 복사

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

객체 타입의 한계

항상 값을 복사해서 사용하면 공유 참조로 인해 발생하는 부작용을 피할 수 있다.
문제는 임베디드 타입처럼 직접 정의한 값 타입은 자바의 기본타입이 아니라 객체 타입이다.
자바 기본 타입에 값을 대입하면 값을 복사한다.
객체 타입은 참조 값을 직접 대입하는 것을 막을 방법이 없다.
객체의 공유 참조는 피할 수 없다.

불변 객체

불변 객체
- 생성 시점 이후 절대 값을 변경할 수 없는 객체
객체 타입을 수정할 수 없게 만들면 부작용을 원천적으로 차단할 수 있다.
값 타입은 불변 객체(immutable object)로 설계해야 한다.
생성자로만 값을 설정하고 수정자(Setter)를 만들지 않으면 된다.
- 만약 값을 수정하고 싶을 때는 생성자로 새로 만들어야 한다.
- Setter 메소드를 private로 만드는 방법도 있다.
Integer, String은 Java가 제공하는 대표적인 불변 객체다.

불변 객체 사용 시 값을 수정하는 예시
Address address = new Address(“oldCity”, “street”, “zipcode”);
…
member1.setHomeAddress(address);
…
Address copyAddress = new Address(address.getCity(), address.getStreet(), address.getZipcode());
…
member2.setHomeAddress(copyAddress);
…
Address newAddress = new Address(“newCity”, address.getStreet(), address.getZipcode());
member1.setHomeAddress(newAddress);

값 타입 복사의 문제 예시

Address address = new Address("oldCity", "street", "zipcode");
			
Member member1 = new Member();
member1.setName("member1");
member1.setHomeAddress(address);
em.persist(member1);

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

//member1과 member2의 city 값이 모두 변경된다. (★★★ 사이드 이펙트 발생 ★★★)
member1.getHomeAddress().setCity("newCity");

tx.commit(); //UPDATE 쿼리 2번 발생

값 타입 복사의 해결 예시

Address address = new Address("oldCity", "street", "zipcode");
			
Member member1 = new Member();
member1.setName("member1");
member1.setHomeAddress(address);
em.persist(member1);

//원본을 복사해서 사용한다. (★★★ 중요 ★★★)
Address copyAddress = new Address(address.getCity(), address.getStreet(), address.getZipcode());

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

//setter가 없으니 객체를 새로 생성한다.
Address newAddress = new Address("newCity", address.getStreet(), address.getZipcode());
member1.setHomeAddress(newAddress);

tx.commit(); //UPDATE 쿼리 1번 발생

값 타입의 비교

값 타입은 인스턴스가 달라도 그 안에 값이 같으면 같은 것으로 취급한다.
비교 종류
- 동일성(identity) 비교
  - 인스턴스의 참조 값을 비교한다.
  - == 연산자를 통해서 비교한다.
- 동등성(equivalence) 비교
  - 인스턴스의 값을 비교
  - equals() 메소드를 통해서 비교한다.
값 타입은 a.equals(b)를 사용해서 동등성 비교를 해야 한다.
값 타입의 equals() 메소드를 적절하게 재정의하여 사용한다.
- 주로 모든 필드를 사용해서 비교한다.

테스트

//s:클래스 정의
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;
    }
	
	@Override
	public int hashCode() {
		return Objects.hash(city, street, zipcode);
	}
	
	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Address other = (Address) obj;
		return Objects.equals(city, other.city) && Objects.equals(street, other.street)
				&& Objects.equals(zipcode, other.zipcode);
	}
}
//e:클래스 정의

//s:예시 코드
Address address1 = new Address("oldCity", "street", "zipcode");
Address address2 = new Address("oldCity", "street", "zipcode");

System.out.println("address1 == address2 : " + (address1 == address2)); //출력 : false
System.out.println("address1 equals address2 : " + (address1.equals(address2))); //출력 : true
//e:예시 코드

값 타입 컬렉션

값 타입을 하나 이상 저장할 때 사용g한다.
데이터베이스는 컬렉션을 같은 테이블에 저장할 수 없다.
컬렉션을 저장하기 위한 별도의 테이블이 필요하다.
컬렉션은 지연 로딩이 사용된다.
요소를 삭제시키기 위해서는 완전히 동일한 데이터를 갖고 있다고 인식시켜야 한다.
- 즉, equals() 메소드와 hashCode() 메소드의 역할이 매우 중요해진다.
값 타입 컬렉션은 영속성 전이 기능과 고아 객체 제거 기능을 필수로 가진다고 볼 수 있다.
값 타입은 엔티티와 다르게 식별자 개념이 없다.
값 타입은 변경하면 추적이 어렵다.
값 타입 컬렉션에 변경 사항이 발생하면,
주인 엔티티와 연관된모든 데이터를 삭제하고,
값 타입 컬렉션에 있는 현재 값을 모두 다시 저장한다.
값 타입 컬렉션을 매핑하는 테이블은 모든 컬럼을 묶어서 기본키를 구성해야 한다.
- NULL이 입력되면 안 된다.
- 중복 값이 저장되면 안 된다.
실무에서는 상황에 따라 값 타입 컬렉션 대신에 일대다 관계를 고려한다.
- 일대다 관계를 위한 엔티티를 만들고, 해당 엔티티에서 값 타입을 사용한다.
- 영속성 전이 기능과 고아 객체 제거 기능을 사용해서 값 타입 컬렉션 처럼 사용한다.
관련 어노테이션
- @ElementCollection
  - 해당 필드가 값 컬렉션인 것을 명시한다.
- @CollectionTable
  - 컬렉션용 테이블 관련 설정을 명시한다.

엔티티 정의

@Embeddable
@Getter
@NoArgsConstructor
@AllArgsConstructor
public class Address {
	private String city;
	private String street;
	private String zipcode;
}

@Embeddable
@Getter
@NoArgsConstructor
@AllArgsConstructor
public class Period {
	private LocalDateTime startDate;
	private LocalDateTime endDate;
}

@Entity
@Data
public class Member {
	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	private Long id;
	
	private String name;
	
	@Embedded
	Period workPeriod; //기간
	
	@Embedded
	Address homeAddress; //자택 주소
	
	@ElementCollection
	@CollectionTable(name = "favorite_food", joinColumns = @JoinColumn(name="member_id")) //favorite_food(member_id, food_name)라는 형태의 테이블이 생성됨
	@Column(name = "food_name")
	private Set<String> favoriteFoods = new HashSet<>();
	
	@ElementCollection
	@CollectionTable(name = "address", joinColumns = @JoinColumn(name="member_id")) //address(member_id, city, street, zipcode)라는 형태의 테이블이 생성됨
	private List<Address> addressHistory = new ArrayList<>();

    //값 타입 컬렉션을 엔티티로 변경하는 경우
    /*
        @OneToMany(cascade = CascadeType.ALL, orphanRemoval = true)
        @JoinColumn(name = "member_id")
        private List<AddressEntity> addressHistory = new ArrayList<>();
    */
}

//값 타입 컬렉션을 엔티티로 변경하는 경우
@Entity(name = "address")
@Data
@NoArgsConstructor
@AllArgsConstructor
public class AddressEntity {
	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	private Long id;
	
	private Address address;
	
}

생성된 테이블

create table address (
    member_id bigint not null,
    city varchar(255),
    street varchar(255),
    zipcode varchar(255)
) engine=InnoDB

create table favorite_food (
    member_id bigint not null,
    food_name varchar(255)
) engine=InnoDB

create table Member (
    id bigint not null auto_increment,
    city varchar(255),
    street varchar(255),
    zipcode varchar(255),
    name varchar(255),
    endDate datetime(6),
    startDate datetime(6),
    primary key (id)
) engine=InnoDB

테스트

Member member = new Member();
member.setName("member");
member.setHomeAddress(new Address("city3", "street3", "zipcode3"));

member.getFavoriteFoods().add("치킨");
member.getFavoriteFoods().add("족발");
member.getFavoriteFoods().add("피자");
			
em.persist(member);

em.flush();
em.clear();

Member findMember = em.find(Member.class, member.getId()); //Member만 조회한다. => 컬렉션은 지연 로딩을 사용한다.

Address currentAddress = findMember.getHomeAddress();
findMember.setHomeAddress(new Address("newCity", currentAddress.getStreet(), currentAddress.getZipcode()));

findMember.getFavoriteFoods().remove("치킨");
findMember.getFavoriteFoods().add("한식");

em.flush();
em.remove(findMember); //관련된 데이터가 같이 지워진다.

tx.commit();

insert 
into
    Member (city, street, zipcode, name, endDate, startDate) 
values
    (?, ?, ?, ?, ?, ?)

insert 
into
    favorite_food (member_id, food_name) 
values
    (?, ?)

insert 
into
    favorite_food (member_id, food_name) 
values
    (?, ?)

insert 
into
    favorite_food (member_id, food_name) 
values
    (?, ?)

select
    m1_0.id,
    m1_0.city,
    m1_0.street,
    m1_0.zipcode,
    m1_0.name,
    m1_0.endDate,
    m1_0.startDate 
from
    Member m1_0 
where
    m1_0.id=?

select
    f1_0.member_id,
    f1_0.food_name 
from
    favorite_food f1_0 
where
    f1_0.member_id=?

update Member 
set
    city=?,
    street=?,
    zipcode=?,
    name=?,
    endDate=?,
    startDate=? 
where
    id=?

delete 
from
    favorite_food 
where
    member_id=? 
    and food_name=?

insert 
into
    favorite_food (member_id, food_name) 
values
    (?, ?)

delete 
from
    address 
where
    member_id=?

delete 
from
    favorite_food 
where
    member_id=?

delete 
from
    Member 
where
    id=?

공통 코드

EntityManagerFactory emf = Persistence.createEntityManagerFactory("hello"); //애플리케이션 전체 공유 (persistence.xml 참조)
EntityManager em = emf.createEntityManager(); //한번 쓰고 버려야함, 쓰레드간 공유하지 않음
EntityTransaction tx = em.getTransaction(); //조회를 제외한 DML 작업시 필수로 사용
tx.begin();

try {
    //실행 내용
} catch (Exception e) {
    e.printStackTrace();
    tx.rollback();
} finally {
    em.close();
}

emf.close();

출처

자바 ORM 표준 JPA 프로그래밍 - 기본편

[JPA 기본] 값 타입

기본값 타입

JPA의 데이터 타입 분류

값 타입 분류

기본값 타입

임베디드 타입

임베디드 타입과 테이블 매핑

엔티티 정의

생성된 테이블

테스트

값 타입과 불변 객체

값 타입 공유 참조

값 타입 복사

객체 타입의 한계

불변 객체

값 타입 복사의 문제 예시

값 타입 복사의 해결 예시

값 타입의 비교

테스트

값 타입 컬렉션

엔티티 정의

생성된 테이블

테스트

공통 코드

출처

관련된 글

[JPA 활용] 지연 로딩과 조회 성능 최적화

[JPA 활용] 컬렉션 조회 최적화

[JPA 활용] OSIV와 성능 최적화