Spring Data JPA - ID 생성 전략과 채번은 어떻게 되는걸까?

@Id, @GeneratedValue 동작방식을 톺아보자.

JPA를 사용할 때 아래와 같은 코드를 무의식적으로 작성을 하게 된다.

@Entity
public class TestEntity {

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

    private String name;
}

이렇게 생성한 Entity 클래스에서 ID 생성 전략과 채번은 어떻게 되는건지, 자세히 살펴보도록 하자.

@Id

package jakarta.persistence;

import java.lang.annotation.Target;
import java.lang.annotation.Retention;
import static java.lang.annotation.ElementType.FIELD;
import static java.lang.annotation.ElementType.METHOD;
import static java.lang.annotation.RetentionPolicy.RUNTIME;

/**
 * Specifies the primary key of an entity.
 * The field or property to which the <code>Id</code> annotation is applied 
 * should be one of the following types: any Java primitive type; 
 * any primitive wrapper type; 
 * <code>String</code>; 
 * <code>java.util.Date</code>; 
 * <code>java.sql.Date</code>; 
 * <code>java.math.BigDecimal</code>;
 * <code>java.math.BigInteger</code>.
 *
 * <p>The mapped column for the primary key of the entity is assumed 
 * to be the primary key of the primary table. If no <code>Column</code> annotation 
 * is specified, the primary key column name is assumed to be the name 
 * of the primary key property or field.
 *
 * <pre>
 *   Example:
 *
 *   @Id
 *   public Long getId() { return id; }
 * </pre>
 *
 * @see Column
 * @see GeneratedValue
 *
 * @since 1.0
 */
@Target({METHOD, FIELD})
@Retention(RUNTIME)

public @interface Id {}

@Id 는 JPA 엔티티의 기본 키(Primary Key)를 식별하기 위한 용도이다.

지원하는 타입은 다음과 같다.

• 자바 기본 타입 (primitive type)

• 기본 타입의 래퍼 클래스(primitive wrapper type)

• String

• java.util.Date / java.sql.Date

• java.math.BigDecimal / java.math.BigInteger

또한, 필드와 프로퍼티 기반으로 적용을 할 수 있다.

필드 기반

@Entity
public class TestEntity {

    @Id // @Id가 필드에 붙음
    private Long id; 
    
    private String name;
}

프로퍼티 기반

@Entity
public class TestEntity {

    private Long id;
    private String name;

    @Id // @Id가 Getter 메서드에 붙음
    public Long getId() { 
        return this.id;
    } 
}

위와 같은 방식으로 기본 키(Primary Key)를 식별할 수 있도록 명시해주는 역할을 하게 된다. @Entity 를 선언해 JPA Entity 라는 것을 명시한 클래스에서는 반드시 @Id 가 필요하다.

선언하지 않았을 때의 모습

@GeneratedValue

/**
 * Provides for the specification of generation strategies for the
 * values of primary keys. 
 *
 * <p> The <code>GeneratedValue</code> annotation
 * may be applied to a primary key property or field of an entity or
 * mapped superclass in conjunction with the {@link Id} annotation.
 * The use of the <code>GeneratedValue</code> annotation is only
 * required to be supported for simple primary keys.  Use of the
 * <code>GeneratedValue</code> annotation is not supported for derived
 * primary keys.
 *
 * <pre>
 *
 *     Example 1:
 *
 *     @Id
 *     @GeneratedValue(strategy=SEQUENCE, generator="CUST_SEQ")
 *     @Column(name="CUST_ID")
 *     public Long getId() { return id; }
 *
 *     Example 2:
 *
 *     @Id
 *     @GeneratedValue(strategy=TABLE, generator="CUST_GEN")
 *     @Column(name="CUST_ID")
 *     Long id;
 * </pre>
 *
 * @see Id
 * @see TableGenerator
 * @see SequenceGenerator
 *
 * @since 1.0
 */
@Target({METHOD, FIELD})
@Retention(RUNTIME)

public @interface GeneratedValue {

    /**
     * (Optional) The primary key generation strategy
     * that the persistence provider must use to
     * generate the annotated entity primary key.
     */
    GenerationType strategy() default AUTO;

    /**
     * (Optional) The name of the primary key generator
     * to use as specified in the {@link SequenceGenerator} 
     * or {@link TableGenerator} annotation.
     * <p> Defaults to the id generator supplied by persistence provider.
     */
    String generator() default "";
}

@GeneratedValue 는 Javadoc 가장 첫 줄에 설명되어 있듯이, 기본 키 값에 대한 생성 전략에 대한 명세(specification)을 제공한다. 즉, 어떻게 기본 키 값을 생성할 것인지에 대한 정보를 제공해준다.

만약 @GeneratedValue 가 없다면, 기본 키를 직접 할당해야 한다.

두 가지 방식을 통해 기본키 생성 전략을 지정할 수 있다.

1. GenerationType 을 지정한다.

   1. ENUM 값으로 5가지(TABLE, SEQUENCE, IDENTITY, UUID, AUTO) 방식을 제공한다.

2. 사용자가 정의한 기본 키 생성기(generator)를 지정한다.

   1. @SequenceGenerator , @TableGenerator를 사용하는 경우

   2. 별도로 아이디값 지정이 필요한 경우 (snowflake, uuid ...)

이번 글에서는 GenerationType 에 대해서만 살펴보도록 하자.

GenerationType

public enum GenerationType { 
    TABLE, 
    SEQUENCE, 
    IDENTITY,
    UUID,
    AUTO
}

Spring Boot 3 (Hibernate 6.x) 버전부터 GenerationType.UUID가 새로 도입되었다.

TABLE

• 데이터베이스 테이블을 사용하여 기본 키를 할당

• 영속성 제공자(persistence provider)가 기본 키를 할당

SEQUNCE

• 데이터베이스 시퀀스를 사용하여 기본 키를 할당

• 순차적으로 증가하는 고유한 값을 생성

IDENTITY

• 데이터베이스의 자동 증가(identity) 컬럼을 사용하여 기본 키를 할당

• 데이터베이스의 AUTO_INCREMENT 기능을 활용

UUID

• RFC 4122 UUID(Universally Unique IDentifier)를 생성하여 기본 키를 할당

• 전역적으로 고유한 식별자를 생성

AUTO

• 특정 데이터베이스에 적합한 전략을 영속성 제공자가 선택하여 기본 키를 할당

• 데이터베이스 리소스가 이미 존재하는 것을 기대하거나, 필요시 생성하려고 시도할 수 있음.

Hibernate의 식별자 생성 전략 내부 구현 분석

위의 5가지 전략 모두 GenerationTypeStrategy 인터페이스를 구현한 구현체로 존재한다. 구현체는 단순 명세 역할을 하며, 이를 싱글톤 패턴을 활용하여 구현되어있다.

example - IdentityGenerationTypeStrategy

이를 실제로 관리하는 주체는 StandardIdentifierGeneratorFactory 클래스이다. 클래스 내부에서 ConcurrentHashMap을 사용하여 각 GenerationType에 대응하는 식별자 생성 전략(GenerationTypeStrategy)을 관리한다.

StandardIdentifierGeneratorFactory.class

public class StandardIdentifierGeneratorFactory
		implements IdentifierGeneratorFactory, BeanContainer.LifecycleOptions, Serializable {

	// 생성 전략 관리 Map
	private final ConcurrentHashMap<GenerationType, GenerationTypeStrategy> generatorTypeStrategyMap = new ConcurrentHashMap<>();
	
	// ...

	// 생성 전략 초기화 GenerationType : GenerationTypeStrategy(singleton instance)
	private void registerJpaGenerators() {
		generatorTypeStrategyMap.put( GenerationType.AUTO, AutoGenerationTypeStrategy.INSTANCE );
		generatorTypeStrategyMap.put( GenerationType.SEQUENCE, SequenceGenerationTypeStrategy.INSTANCE );
		generatorTypeStrategyMap.put( GenerationType.TABLE, TableGenerationTypeStrategy.INSTANCE );
		generatorTypeStrategyMap.put( GenerationType.IDENTITY, IdentityGenerationTypeStrategy.INSTANCE );
		generatorTypeStrategyMap.put( GenerationType.UUID, UUIDGenerationTypeStrategy.INSTANCE );
	}
}

내부적으로 아래의 메서드를 통해 식별자 생성기를 생성하는 역할을 한다.

@Override
public IdentifierGenerator createIdentifierGenerator(
       GenerationType generationType,
       String generatedValueGeneratorName,
       String generatorName,
       JavaType<?> javaType,
       Properties config,
       GeneratorDefinitionResolver definitionResolver) {
    final GenerationTypeStrategy strategy = generatorTypeStrategyMap.get( generationType );
    if ( strategy != null ) {
       return strategy.createIdentifierGenerator(
             generationType,
             generatorName,
             javaType,
             config,
             definitionResolver,
             serviceRegistry
       );
    }
    throw new UnsupportedOperationException( "No GenerationTypeStrategy specified" );
}

주어진 GenerationType 에 맞는 전략을 Map 에서 찾아 createIdentifierGenerator 메서드를 호출하게 된다. 이 과정을 통해 적절한 IdentifierGenerator 구현체가 생성되는 것이다.

위에서 언급했듯이 모든 식별자 생성기는 IdentifierGenerator 인터페이스를 구현한다. 이 인터페이스의 핵심 메서드는 generate 로 어떤 방식으로 생성할지 정하게 되는 것이다.

IdentifierGenerator - generate()

example - IncrementGenerator

public class IncrementGenerator implements IdentifierGenerator, StandardGenerator {

	// ... 
	
	@Override
	public synchronized Object generate(SharedSessionContractImplementor session, Object object) throws HibernateException {
		if ( sql != null ) {
			initializePreviousValueHolder( session );
		}
		return previousValueHolder.makeValueThenIncrement();
	}

}

synchronized 키워드를 통해 멀티스레드 환경에서 안전하게 작동되며, previousValueHolder 를 통해 이전 값을 기반으로 새 값을 생성하고 증가시킨다.

ID 생성 전략 초기화 흐름 정리

1. 초기화 단계: 애플리케이션 시작 시 StandardIdentifierGeneratorFactory가 초기화되고, registerJpaGenerators() 메서드를 통해 각 GenerationType에 대한 전략이 Map에 등록

2. 엔티티 매핑 단계: 엔티티 클래스의 @GeneratedValue 어노테이션에 지정된 strategy 값에 따라 적절한GenerationTypeStrategy 선택

3. 식별자 생성기 생성 단계: 선택된 전략의 createIdentifierGenerator 메서드가 호출되어 실제 IdentifierGenerator 구현체가 생성

4. 식별자 생성 단계: 엔티티가 영속화될 때 생성된 IdentifierGenerator의 generate 메서드가 호출되어 새로운 식별자 값이 생성

여기서 설명한 내용들은 스프링 부트가 시작될 때 Entity를 스캔하고 각 엔티티에 적절한 ID 생성 전략을 미리 구성하는 방식으로 동작하는 것이다.

EntityManagerFactory가 초기화되면서 EntityPersister 인터페이스의 getGenerator() 메서드를 통해 각 엔티티에 맞는 ID 생성기가 할당되게 된다.

ID 채번 테스트

위에서 확인했던 내용들을 기반으로 Break Point를 걸고, SAVE 호출시에 위의 설정 과정을 어떻게 활용하는지 파악해보자.

Entity

/**
 * Identity Test Entity.
 *
 * @author Seungjo, Jeong
 */
@ToString
@Getter
@Entity
@Table(name = "identity_test")
@NoArgsConstructor
public class IdentityEntity {

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

    public IdentityEntity(String name) {
        this.name = name;
    }
}

테스트는 단순하게 JpaRepository의 save 메서드를 테스트한다.

@Test
@DisplayName("Identity 엔티티를 저장해보자.")
void test1() {

    IdentityEntity entity = new IdentityEntity("auto-increment");

    // break-point
    identityRepository.save(entity);
}

1. SimpleJpaRepository.save()

save 메서드를 호출하면 엔티티가 새로운 엔티티인지 확인 후, 새로운 엔티티라면 EntityManager.persist()를 호출하게 된다.

이 때 내부적으로 hibernate의 Session.persist() 로 위임이 되고, 이는 다시 AbstractSaveEventListener.performSave() 를 호출하게 된다.

여기서 새로운 엔티티로 판단하는 entityInformation.isNew(entity) 에 대한 설명은 제외하도록 한다.

2. AbstractSaveEventListener.performSave()

엔티티의 저장 프로세스를 처리하는 메서드

protected Object performSave(
        Object entity,
        Object id,
        EntityPersister persister,
        boolean useIdentityColumn,
        Object anything,
        EventSource source,
        boolean requiresImmediateIdAccess) {
    
    // (1) 콜백 처리
    callbackRegistry.preCreate(entity);
    
    // (2) EntityPersister 에서 생성 전략 획득 
    final Generator generator = persister.getGenerator();
    if ( generator instanceof Assigned || generator instanceof CompositeNestedGeneratedValueGenerator ) {
        // ...
    }

    
    // 나머지 저장 로직
    // ...
    return performSaveOrReplicate(entity, key, persister, useIdentityColumn, anything, source, requiresImmediateIdAccess);
}

1. 콜백 처리

callbackRegistry.preCreate(entity) 메서드는 @PrePersist 작업에 대한 처리를 DB로 INSERT 쿼리를 날리기 전에 작업하도록 호출하는 것이다. (ex. @CreatedDate 와 같은 작업)

1. 생성 전략 획득 및 비교 로직 수행

Entity의 ID Generate 전략 가져오기 (EntityPersister)

내부적으로 어떤 전략을 사용하는지 가져오게 되며, 그 전략을 기반으로 ID 값을 생성하고자 한다.

현재 IDENTITY 전략을 사용하는 엔티티의 경우 ID는 데이터베이스에 INSERT 후 생성되기 때문에 performSave() 메서드에서 performSaveOrReplicate() 메서드로 들어가게 된다.

3. AbstractSaveEventListener.performSaveOrReplicate()

private Object performSaveOrReplicate(
        Object entity,
        EntityKey key,
        EntityPersister persister,
        boolean useIdentityColumn,
        Object anything,
        EventSource source,
        boolean requiresImmediateIdAccess) {
    
    // ...
    
    final AbstractEntityInsertAction insert = addInsertAction(
            cloneAndSubstituteValues(entity, persister, anything, source, id),
            id,
            entity,
            persister,
            useIdentityColumn,
            source,
            requiresImmediateIdAccess
    );

    cascadeAfterSave(source, persister, entity, anything);

    final Object finalId = handleGeneratedId(useIdentityColumn, id, insert);
    
    // ...
    
    return finalId;
}

엔티티를 삽입하기 위한 AbstractEntityInsertAction을 생성하고, handleGenerataedId 메서드를 통해 생성된 ID를 처리하게 된다.

4. AbstractSaveEventListener.handleGeneratedId()

private static Object handleGeneratedId(boolean useIdentityColumn, Object id, AbstractEntityInsertAction insert) {
    if (useIdentityColumn && insert.isEarlyInsert()) {
        if (insert instanceof EntityIdentityInsertAction) {
            final Object generatedId = ((EntityIdentityInsertAction) insert).getGeneratedId();
            insert.handleNaturalIdPostSaveNotifications(generatedId);
            return generatedId;
        }
        else {
            throw new IllegalStateException(
                    "Insert should be using an identity column, but action is of unexpected type: "
                            + insert.getClass().getName()
            );
        }
    }
    else {
        return id;
    }
}

IDENTITY 전략을 통해 즉시 삽입이 필요한 경우(useIdentityColumn && insert.isEarlyInsert()), EntityIdentityInsertAction 에서 생성된 ID를 가져오게 된다. 이는 데이터베이스에서 INSERT 쿼리가 실행된 후 얻어진 값이다.

5. EntityIdentityInsertAction.addInsertAction()

private AbstractEntityInsertAction addInsertAction(
	Object[] values,
	Object id,
	Object entity,
	EntityPersister persister,
	boolean useIdentityColumn,
	EventSource source,
	boolean delayIdentityInserts) {
		if ( useIdentityColumn ) {
		final EntityIdentityInsertAction insert = new EntityIdentityInsertAction(
				values,
				entity,
				persister,
				isVersionIncrementDisabled(),
				source,
				delayIdentityInserts
		);
		source.getActionQueue().addAction( insert );
		return insert;
}

위와 같은 메서드를 호출해서 DB에 INSERT 쿼리를 날리면서 ID 값을 가져온다.

EntityIdentityInsertAction 에서 ID 값을 가져오는 방식

• 데이터베이스에 INSERT 쿼리를 실행

• 데이터베이스에서 생성된 ID 값을 가져온다.

• 가져온 ID 값을 엔티티에 할당

ID 채번 동작 흐름 정리

1. SimpleJpaRepository.save() 호출

2. 엔티티가 새로운 엔티티인지 확인

3. 새로운 엔티티라면 EntityManager.persist() 호출

4. Hibernate의 Session.persist() 로 위임

5. AbstractSaveEventListener.performSave() 호출

6. 콜백 처리(@PrePersist) 및 ID 생성 전략 확인

7. performSaveOrReplicate() 호출

8. EntityIentityInsertAction 생성 및 실행

9. 데이터베이스에 INSERT 쿼리 실행 후 ID 값 얻어오기

10. 생성된 ID 값을 엔티티에 설정

entityManager.persist(entity) 메서드 내부에서 정말 많은 동작이 수행된다. 보면 볼수록 신기하다.

---

결론

JPA를 사용하는 상황에서 save() 메서드 호출 시 내부적으로 일어나는 ID 생성 전략에 따른 채번 과정을 디버깅을 통해 하나씩 흐름을 따라가며 살펴보았다. 새로운 엔티티를 판별하는 로직만 알고 있었지만, 생성 과정은 더욱 복잡한 과정을 거쳐 ID 값이 생성되고 할당되는 것을 알게 되었다.

JPA의 ID 생성 메커니즘은 단순 ID 값 생성을 넘어 영속성 컨텍스트 관리, 트랜잭션 처리, 성능 최적화 등 다양한 측면과 밀접한 관계가 있어보인다. 이러한 정보를 기반으로 커스터마이징이나 별도의 최적화가 필요한 경우 잘 적용할 수 있지 않을까?