[JPA] 엔티티 매핑(Entity Mapping)

ReBugs

|2024. 7. 16. 15:08

이 글은 인프런 김영한님의 Spring 강의를 바탕으로 개인적인 정리를 위해 작성한 글입니다.

데이터베이스 스키마 자동 생성

application.properties

spring.jpa.hibernate.ddl-auto=create
spring.jpa.hibernate.ddl-auto=create-drop
spring.jpa.hibernate.ddl-auto=update
spring.jpa.hibernate.ddl-auto=validate
spring.jpa.hibernate.ddl-auto=none

create

설명: 기존 테이블을 삭제한 후 다시 생성한다. (DROP + CREATE)
사용 예시: 개발 초기 단계에서 데이터베이스 스키마를 자주 변경할 때 사용된다. 기존 데이터를 모두 삭제하고 테이블을 새로 생성하기 때문에 주의가 필요하다.

create-drop

설명: create와 같지만, 애플리케이션 종료 시점에 테이블을 삭제한다.
사용 예시: 테스트 환경에서 애플리케이션 실행 중에만 테이블을 유지하고 종료 시 데이터를 삭제하고 싶을 때 사용된다

update

설명: 변경된 부분만 반영한다. (운영 데이터베이스에는 사용하지 않음)
사용 예시: 개발 또는 테스트 단계에서 엔티티의 변경 사항을 데이터베이스 테이블에 반영할 때 사용된다. 운영 환경에서는 데이터 손실이나 예상치 못한 오류를 방지하기 위해 사용하지 않는 것이 좋다.

validate

설명: 엔티티와 테이블이 정상 매핑되었는지 확인한다.
사용 예시: 데이터베이스 스키마가 애플리케이션의 엔티티 클래스와 일치하는지 검증할 때 사용된다. 스키마 변경 없이 검증만 수행하므로 안전하다.

none

설명: 아무 작업도 하지 않는다.
사용 예시: 데이터베이스 스키마를 자동으로 변경하거나 검증하지 않고, 수동으로 관리하고 싶을 때 사용된다.

운영 서버에서는 절대 create, create-drop, update를 사용하면 안된다.

-개발 초기 단계에는 create 또는 update 사용
-테스트 서버는 update 또는 validate 사용
-스테이징과 운영 서버는 validate 또는 none 사용

객체와 테이블 매핑

@Entity

@Entity 어노테이션은 해당 클래스가 JPA 엔티티임을 명시한다. 엔티티 클래스는 데이터베이스 테이블에 매핑되며, 각 인스턴스는 테이블의 행을 나타낸다.

JPA를 사용해서 테이블과 매핑할 클래스는 @Entity가 필수이다.

import javax.persistence.Entity;
import javax.persistence.Id;

@Entity
public class MyEntity {
    @Id
    private Long id;

    private String name;

    public MyEntity(){ //기본 생성자
    }
    // getters and setters
}

주의 사항

엔티티 클래스는 반드시 기본 키(primary key)를 지정해야 하며, 이를 위해 @Id 어노테이션을 사용한다.
기본 생성자가 필수적이다.(파라미터가 없는 public 또는 protected 생성자)
final 클래스, enum, interface, inner 클래스에는 적용할 수 없다.
@Entity 애노테이션이 있는 클래스의 저장할 필드에는 final 접근제한자를 사용할 수 없다.

@Table

@Table 어노테이션은 엔티티 클래스를 특정 데이터베이스 테이블과 매핑하는 데 사용된다. 주로 테이블 이름이나 스키마를 지정하는 데 사용된다.

@Table 어노테이션을 사용하여 엔티티가 매핑될 데이터베이스 테이블의 이름을 지정할 수 있다.

schema 속성을 사용하여 테이블이 속한 스키마를 지정할 수 있다.

테이블 이름과 클래스 이름이 다를 경우, @Table 어노테이션을 사용하여 명시적으로 매핑해야 한다.

import javax.persistence.Entity;
import javax.persistence.Table;
import javax.persistence.Id;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;

@Entity
@Table(name = "employees", schema = "hr")
public class Employee {
    @Id
    private Long id;

    private String firstName;
    private String lastName;
    private String email;

    // getters and setters
}

이 예제에서 Employee 클래스는 employees 테이블에 매핑되며, 해당 테이블은 hr 스키마에 속해 있다.

@Entity: Employee 클래스가 JPA 엔티티임을 명시한다.
@Table(name = "employees", schema = "hr"): Employee 엔티티가 hr 스키마의 employees 테이블에 매핑됨을 지정한다.
@Id: id 필드를 기본 키로 지정한다.

필드와 컬럼 매핑

@Column

Column 어노테이션은 JPA(Java Persistence API)에서 엔티티 클래스의 필드를 데이터베이스 테이블의 컬럼에 매핑하는 데 사용된다. 이 어노테이션을 통해 필드와 컬럼 간의 세부 매핑을 설정할 수 있다.

@Column 어노테이션은 주로 필드 이름, 데이터 타입, 크기, 제약 조건 등을 명시적으로 지정할 때 사용된다.

name: 매핑할 데이터베이스 컬럼의 이름을 지정한다.
nullable: 컬럼이 NULL 값을 가질 수 있는지 여부를 지정한다. 기본값은 true이다.
unique: 컬럼 값의 고유성을 지정한다. 기본값은 false이다.
length: 문자열 컬럼의 길이를 지정한다. 기본값은 255이다.
precision: 소수점 숫자 타입의 전체 자릿수를 지정한다.
scale: 소수점 이하의 자릿수를 지정한다.
insertable : 이 속성이 true라면, 해당 필드에 대해 INSERT 쿼리문이 무시된다.
updatable : 이 속성이 true라면, 해당 필드에 대해 UPDATE 쿼리문이 무시된다.

import javax.persistence.Entity;
import javax.persistence.Table;
import javax.persistence.Id;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Column;

@Entity
@Table(name = "employees")
public class Employee {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(name = "first_name", nullable = false, length = 50)
    private String firstName;

    @Column(name = "last_name", nullable = false, length = 50)
    private String lastName;

    @Column(name = "email", unique = true, length = 100)
    private String email;

    // getters and setters
}

@Temporal

@Temporal 어노테이션은 자바의 날짜/시간 타입인 java.util.Date 또는 java.util.Calendar를 데이터베이스의 특정 타입으로 매핑할 때 사용된다.

JPA는 날짜와 시간을 여러 가지 형식으로 저장할 수 있는데, @Temporal을 사용하여 이를 명시적으로 지정할 수 있다.

TemporalType.DATE: 날짜 부분만 저장 (yyyy-MM-dd)
TemporalType.TIME: 시간 부분만 저장 (HH:mm:ss)
TemporalType.TIMESTAMP: 날짜와 시간 모두 저장 (yyyy-MM-dd HH:mm:ss.SSS)

import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Temporal;
import javax.persistence.TemporalType;
import java.util.Date;

@Entity
public class Event {
    @Id
    private Long id;

    @Temporal(TemporalType.DATE)
    private Date eventDate;

    @Temporal(TemporalType.TIME)
    private Date eventTime;

    @Temporal(TemporalType.TIMESTAMP)
    private Date eventTimestamp;

    // getters and setters
}

위 예시에서 eventDate는 날짜만 저장되고, eventTime은 시간만 저장되며, eventTimestamp는 날짜와 시간을 모두 저장한다.

@Enumerated

@Enumerated 어노테이션은 자바의 열거형 타입(enum)을 데이터베이스에 저장할 때 사용된다. 이 어노테이션을 사용하여 열거형이 데이터베이스에 어떻게 저장될지를 명시할 수 있다.

EnumType.ORDINAL: 열거형의 순서 값(정수)으로 저장된다. -> 사용 자제
EnumType.STRING: 열거형의 이름(문자열)으로 저장된다.

import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Enumerated;
import javax.persistence.EnumType;

@Entity
public class User {
    @Id
    private Long id;

    @Enumerated(EnumType.STRING)
    private UserRole role;

    // getters and setters

    public enum UserRole {
        ADMIN,
        USER,
        GUEST
    }
}

위 예시에서 role 필드는 열거형 UserRole을 사용하며, 데이터베이스에는 문자열로 저장된다. 따라서 ADMIN, USER, GUEST 값이 그대로 저장된다.

@Lob

@Lob(Large Object) 어노테이션은 대용량 데이터(텍스트 또는 바이너리 데이터)를 데이터베이스에 저장할 때 사용된다. 보통 BLOB(Binary Large Object) 또는 CLOB(Character Large Object) 타입을 사용한다.

매핑하는 필드 타입이 문자면 CLOB 매핑, 나머지는 BLOB 매핑

CLOB: String, char[], java.sql.CLOB
BLOB: byte[], java.sql. BLOB

import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Lob;

@Entity
public class Article {
    @Id
    private Long id;

    @Lob
    private String content;

    // getters and setters
}

위 예시에서 content 필드는 대용량 텍스트 데이터로 저장된다.

import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Lob;

@Entity
public class Image {
    @Id
    private Long id;

    @Lob
    private byte[] data;

    // getters and setters
}

위 예시에서 data 필드는 대용량 바이너리 데이터로 저장된다.

@Transient

@Transient 어노테이션은 특정 필드를 데이터베이스 테이블에 매핑하지 않도록 지정한다.

이 필드는 JPA에 의해 무시되며, 데이터베이스에 저장되지 않는다.

주로 메모리상에서만 임시로 어떤 값을 보관하고 싶을 때 사용

import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Transient;

@Entity
public class Product {
    @Id
    private Long id;

    private String name;

    @Transient
    private int tempPrice;

    // getters and setters
}

위 예시에서 tempPrice 필드는 데이터베이스에 저장되지 않는다. 이는 프로그램 내에서만 사용되는 임시 데이터이다.

기본 키 매핑

시퀀스 전략과 아이덴티티 전략은 데이터베이스에서 기본 키(primary key)를 생성하는 방법으로, 각각의 차이점과 사용 상황을 이해하는 것이 중요하다.

Sequence Strategy와 Identity Strategy

Sequence Strategy

시퀀스 전략은 데이터베이스 시퀀스를 이용해 기본 키 값을 생성하는 방법이다. 시퀀스는 데이터베이스 객체로, 연속적인 숫자 값을 생성한다. 주로 Oracle, PostgreSQL 등에서 사용된다.

장점

시퀀스 객체는 데이터베이스 내부에서 최적화되어 있어 빠르게 고유 값을 생성할 수 있다.
여러 테이블에서 같은 시퀀스를 공유하여 기본 키를 생성할 수 있다.

dentity Strategy

아이덴티티 전략은 기본 키 값을 자동으로 증가시키는 방법이다. 주로 MySQL, SQL Server, DB2 등에서 사용된다. 이 전략은 데이터베이스가 새로운 행이 삽입될 때마다 자동으로 고유 키 값을 생성하도록 한다.

장점

별도의 시퀀스 객체를 생성할 필요 없이, 테이블의 컬럼에 자동 증가 속성을 설정하면 된다.
대부분의 데이터베이스에서 지원하는 기능을 활용하므로 추가 설정이 필요 없다.

차이점

시퀀스 객체의 사용

시퀀스 전략은 데이터베이스 시퀀스 객체를 사용한다.
아이덴티티 전략은 테이블의 자동 증가 속성을 사용한다.

다양한 데이터베이스 지원

시퀀스 전략은 Oracle, PostgreSQL 등에서 주로 사용된다.
아이덴티티 전략은 MySQL, SQL Server 등에서 주로 사용된다.

성능과 활용도

시퀀스 전략은 성능이 우수하고 여러 테이블에서 공유할 수 있다.
아이덴티티 전략은 설정이 간단하고 데이터베이스의 기본 기능을 사용한다.

@Id

@Id 어노테이션은 엔티티 클래스의 필드를 데이터베이스 테이블의 기본 키로 지정한다. 기본 키는 테이블의 각 행을 고유하게 식별하는 데 사용된다.

기본 키를 직접 할당할 때 사용된다.

import javax.persistence.Entity;
import javax.persistence.Id;

@Entity
public class MyEntity {
    @Id
    private Long id;

    // getters and setters
}

위 예시에서 id 필드는 엔티티의 기본 키로 지정되었다.

@GeneratedValue

@GeneratedValue 어노테이션은 기본 키의 값을 자동으로 생성하는 전략을 지정한다.

이 어노테이션은 @Id와 함께 사용되며, 다양한 키 생성 전략을 설정할 수 있다.

strategy: 기본 키 생성 전략을 지정한다.
generator: 시퀀스 생성기나 테이블 생성기의 이름을 지정한다.

Identity 전략

GenerationType.AUTO: JPA 구현체가 데이터베이스에 맞는 전략을 자동으로 선택한다.

@GeneratedValue(strategy = GenerationType.AUTO)
private Long id;

GenerationType.IDENTITY: 데이터베이스의 IDENTITY 열을 사용하여 기본 키 값을 자동으로 생성한다.

주로 MySQL, SQL Server 등에서 사용된다.
JPA는 보통 트랜잭션 커밋 시점에 INSERT SQL 실행
하지만 IDENTITY 전략은 em.persist() 시점에 즉시 INSERT SQL 실행 하고 DB에서 식별자를 조회

@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;

Sequence 전략

데이터베이스 시퀀스는 유일한 값을 순서대로 생성하는 특별한 데이터베이스 오브젝트

@SequenceGenerator

@SequenceGenerator는 데이터베이스 시퀀스를 사용하여 기본 키 값을 생성할 때 사용된다. 시퀀스는 주로 Oracle, PostgreSQL과 같은 데이터베이스에서 지원한다.

name: JPA에서 사용할 시퀀스 생성기의 이름이다.
sequenceName: 데이터베이스 시퀀스의 실제 이름이다.
initialValue: 시퀀스의 초기 값이다.
allocationSize: 시퀀스 값의 증가 크기이다.
- 미리 50개의 시퀀스를 DB에서 확보하고 값이 추가될 때 마다 1개씩 메모리에서 가져와 성능 개선을 하기 위함
- 동시성 이슈가 없다.

데이터베이스 시퀀스 값이 하나씩 증가하도록 설정된 경우 1로 설정

allocationSize
JPA에서 시퀀스를 사용하는 동안 메모리 내에서 미리 할당할 시퀀스 값의 개수를 지정한다. 기본값은 50이다. 즉, 한 번의 데이터베이스 호출로 50개의 시퀀스 값을 미리 할당받아 성능을 향상시킨다.

데이터베이스 시퀀스
데이터베이스 시퀀스는 일반적으로 시퀀스 값이 호출될 때마다 하나씩 증가하도록 설정된다. 예를 들어, INCREMENT BY 1로 설정된다.

JPA는 메모리 내에서 여러 시퀀스 값을 미리 할당받아 사용하지만, 데이터베이스 시퀀스는 여전히 하나씩 증가한다. 이로 인해 두 시스템 간에 불일치가 발생할 수 있다.

그러므로 아래와 같이 설정된 경우 allocationSize 를 1로 설정해야한다.
CREATE SEQUENCE MEMBER_SEQ
    START WITH 1
    INCREMENT BY 1;
성능을 향상시키기 위해서(allocationSize = 50)는 아래와 같이 설정해야 한다.
CREATE SEQUENCE MEMBER_SEQ
    START WITH 1
    INCREMENT BY 50;

import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.SequenceGenerator;

@Entity
@SequenceGenerator(
    name = "MEMBER_SEQ_GENERATOR",
    sequenceName = "MEMBER_SEQ",  // 매핑할 데이터베이스 시퀀스 이름
    initialValue = 1, 
    allocationSize = 1
)
public class Member {
    @Id
    @GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "MEMBER_SEQ_GENERATOR")
    private Long id;
    
    private String name;

    // getters and setters
}

GenerationType.SEQUENCE

데이터베이스 시퀀스를 사용하여 기본 키 값을 생성한다. 시퀀스 이름은 generator 속성으로 지정

@Id
@GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "MEMBER_SEQ_GENERATOR")
private Long id;

두 어노테이션의 결합 사용

CREATE SEQUENCE MEMBER_SEQ
    START WITH 1
    INCREMENT BY 50;

import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.SequenceGenerator;

@Entity
@SequenceGenerator(
    name = "MEMBER_SEQ_GENERATOR",
    sequenceName = "MEMBER_SEQ",  // 매핑할 데이터베이스 시퀀스 이름
    initialValue = 1, 
    allocationSize = 50
)
public class Member {
    @Id
    @GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "MEMBER_SEQ_GENERATOR")
    private Long id;
    
    private String name;

    // getters and setters
}

@SequenceGenerator 어노테이션은 시퀀스 생성기를 정의한다. MEMBER_SEQ_GENERATOR라는 이름으로 생성기를 정의하고, 데이터베이스의 MEMBER_SEQ 시퀀스와 매핑한다.
initialValue는 시퀀스의 초기 값이며, allocationSize는 시퀀스가 증가하는 크기이다.
@GeneratedValue 어노테이션은 strategy를 GenerationType.SEQUENCE로 설정하고, generator 속성에 MEMBER_SEQ_GENERATOR를 지정하여 @SequenceGenerator에서 정의한 시퀀스 생성기를 사용한다.

'Java Category > JPA' 카테고리의 다른 글

[JPA] 프록시(Proxy) (0)	2024.07.26
[JPA] 상속관계 매핑 (0)	2024.07.25
[JPA] 다양한 연관관계 매핑 (5)	2024.07.24
[JPA] 연관관계 매핑(단방향, 양방향)을 통한 객체 그래프 탐색 (0)	2024.07.17
[JPA] 영속성 컨텍스트(Persistence Context) (0)	2024.07.15