JPA 영속성 컨텍스트

dependencies {
    implementation("org.springframework.boot:spring-boot-starter-data-jpa")
    implementation("com.querydsl:querydsl-jpa:5.1.0:jakarta")
    annotationProcessor("com.querydsl:querydsl-apt:5.1.0:jakarta")
    annotationProcessor("jakarta.persistence:jakarta.persistence-api:3.2.0")
    annotationProcessor("jakarta.annotation:jakarta.annotation-api:3.0.0")
    testImplementation(
        "org.springframework.boot:spring-boot-starter-data-jpa-test")
}

tasks.named<JavaCompile>("compileJava") {
    options.compilerArgs.addAll(listOf(
        "-proc:full",
        "-processor",
        "com.querydsl.apt.jpa.JPAAnnotationProcessor",
    ))
}

insert into members(
    id, email, password_hash, name, active, daily_character_limit)
values (41, '[email protected]', 'hash', '회원41', true, 10000);

package board.jpa;

import java.time.Instant;
import java.time.LocalDate;
import java.util.Objects;

import board.application.PostSnapshot;
import board.application.postcreation.CreatePostUseCase.CreatePostCommand;
import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;
import jakarta.persistence.Table;
import jakarta.persistence.UniqueConstraint;
import jakarta.persistence.Version;

@Entity
@Table(
        name = "posts",
        uniqueConstraints = @UniqueConstraint(
                name = "uq_posts_member_request",
                columnNames = {"member_id", "client_request_id"}))
public class PostEntity {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(name = "member_id", nullable = false)
    private long memberId;

    @Column(nullable = false, length = 80)
    private String title;

    @Column(nullable = false, length = 720)
    private String content;

    @Column(name = "published_on", nullable = false)
    private LocalDate publishedOn;

    @Column(name = "client_request_id", nullable = false, length = 64)
    private String clientRequestId;

    @Column(name = "created_at", nullable = false)
    private Instant createdAt;

    @Version
    @Column(nullable = false)
    private long version;

    protected PostEntity() {
    }

    private PostEntity(CreatePostCommand command, Instant createdAt) {
        this.memberId = command.memberId();
        this.title = command.title();
        this.content = command.content();
        this.publishedOn = command.publishedOn();
        this.clientRequestId = command.clientRequestId();
        this.createdAt = Objects.requireNonNull(createdAt, "createdAt");
    }

    static PostEntity create(CreatePostCommand command, Instant createdAt) {
        if (command == null || createdAt == null) {
            throw new IllegalArgumentException("command and createdAt are required");
        }
        return new PostEntity(command, createdAt);
    }

    void changeForPersistenceLesson(String title, String content) {
        if (title == null || title.isBlank() || title.length() > 80
                || content == null || content.isBlank()
                || content.length() > 720) {
            throw new IllegalArgumentException("invalid post change");
        }
        this.title = title;
        this.content = content;
    }

    PostSnapshot snapshot() {
        if (id == null || id <= 0) {
            throw new IllegalStateException("persisted id must be positive");
        }
        return new PostSnapshot(
                id,
                memberId,
                title,
                content,
                publishedOn,
                clientRequestId,
                createdAt,
                version);
    }

    public Long getId() { return id; }
    public long getMemberId() { return memberId; }
    public String getTitle() { return title; }
    public String getContent() { return content; }
    public LocalDate getPublishedOn() { return publishedOn; }
    public String getClientRequestId() { return clientRequestId; }
    public Instant getCreatedAt() { return createdAt; }
    public long getVersion() { return version; }
}

package board.jpa;

import java.time.Instant;
import java.util.Optional;
import java.util.function.Supplier;
import java.util.regex.Pattern;

import board.application.ChangedPost;
import board.application.DeletePostCommand;
import board.application.DuplicatePostRequestException;
import board.application.PostPage;
import board.application.PostPersistenceException;
import board.application.PostQuery;
import board.application.PostRepository;
import board.application.PostSearch;
import board.application.PostSnapshot;
import board.application.PostSummary;
import board.application.postcreation.CreatePostUseCase.CreatePostCommand;
import org.hibernate.exception.ConstraintViolationException;
import org.springframework.stereotype.Repository;

@Repository
public final class JpaPostRepository implements PostRepository, PostQuery {
    private static final Pattern REQUEST_CONSTRAINT = Pattern.compile(
            "(?i)(?:^|[.\\s\"`])uq_posts_member_request"
                    + "(?:_index_\\d+)?(?=$|[.\\s\"`])");
    private static final Pattern REQUEST_ID =
            Pattern.compile("[A-Za-z0-9_-]{8,64}");

    private final PostJpaRepository entities;

    public JpaPostRepository(PostJpaRepository entities) {
        this.entities = entities;
    }

    @Override
    public PostSnapshot create(CreatePostCommand command, Instant createdAt) {
        if (command == null || createdAt == null) {
            throw new IllegalArgumentException("command and createdAt are required");
        }
        PostEntity entity = PostEntity.create(command, createdAt);
        try {
            PostEntity persisted = entities.saveAndFlush(entity);
            if (persisted.getId() == null || persisted.getId() <= 0) {
                throw failure("create returned a non-positive id", null);
            }
            return persisted.snapshot();
        } catch (RuntimeException storageFailure) {
            if (isRequestDuplicate(storageFailure)) {
                throw new DuplicatePostRequestException(
                        command.memberId(),
                        command.clientRequestId(),
                        storageFailure);
            }
            if (storageFailure instanceof PostPersistenceException translated) {
                throw translated;
            }
            throw failure("JPA create failed", storageFailure);
        }
    }

    @Override
    public boolean update(ChangedPost command) {
        if (command == null) {
            throw new IllegalArgumentException("change is required");
        }
        return exactRowCount(
                "update",
                translate("JPA update failed", () -> entities.updateOwned(
                        command.id(),
                        command.memberId(),
                        command.title(),
                        command.content(),
                        command.expectedVersion())));
    }

    @Override
    public boolean delete(DeletePostCommand command) {
        if (command == null) {
            throw new IllegalArgumentException("delete command is required");
        }
        return exactRowCount(
                "delete",
                translate("JPA delete failed", () -> entities.deleteOwned(
                        command.postId(),
                        command.memberId(),
                        command.expectedVersion())));
    }

    @Override
    public Optional<PostSnapshot> find(long postId, long memberId) {
        requirePositive(postId, "postId");
        requirePositive(memberId, "memberId");
        return translate(
                "JPA owner-scoped find failed",
                () -> entities.findByIdAndMemberId(postId, memberId)
                        .map(PostEntity::snapshot));
    }

    @Override
    public Optional<PostSnapshot> findByIdempotencyKey(
            long memberId,
            String clientRequestId
    ) {
        requirePositive(memberId, "memberId");
        if (clientRequestId == null
                || !REQUEST_ID.matcher(clientRequestId).matches()) {
            throw new IllegalArgumentException("invalid clientRequestId");
        }
        return translate(
                "JPA idempotency lookup failed",
                () -> entities
                        .findByMemberIdAndClientRequestId(
                                memberId, clientRequestId)
                        .map(PostEntity::snapshot));
    }

    @Override
    public PostPage findPage(PostSearch search) {
        if (search == null) {
            throw new IllegalArgumentException("search is required");
        }
        return translate("JPA page query failed", () -> entities.findPage(search));
    }

    @Override
    public PostSummary summary(long memberId) {
        requirePositive(memberId, "memberId");
        return translate("JPA summary query failed", () -> entities.summary(memberId));
    }

    private static boolean exactRowCount(String operation, int rows) {
        if (rows == 0) {
            return false;
        }
        if (rows == 1) {
            return true;
        }
        throw failure(
                operation + " changed more than one row",
                new IllegalStateException("changed rows: " + rows));
    }

    private static <T> T translate(String message, Supplier<T> work) {
        try {
            return work.get();
        } catch (PostPersistenceException translated) {
            throw translated;
        } catch (RuntimeException storageFailure) {
            throw failure(message, storageFailure);
        }
    }

    private static boolean isRequestDuplicate(Throwable failure) {
        Throwable current = failure;
        while (current != null) {
            if (current instanceof ConstraintViolationException violation) {
                String name = violation.getConstraintName();
                if (name != null
                        && REQUEST_CONSTRAINT.matcher(name).find()) {
                    return true;
                }
            }
            Throwable next = current.getCause();
            if (next == current) {
                break;
            }
            current = next;
        }
        return false;
    }

    private static PostPersistenceException failure(
            String message,
            Throwable cause
    ) {
        Throwable retained = cause != null
                ? cause
                : new IllegalStateException(message);
        return new PostPersistenceException(message, retained);
    }

    private static void requirePositive(long value, String name) {
        if (value <= 0) {
            throw new IllegalArgumentException(name + " must be positive");
        }
    }
}

package board.jpa;

import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;

import java.time.Instant;
import java.time.LocalDate;

import javax.sql.DataSource;

import board.application.ChangedPost;
import board.application.DeletePostCommand;
import board.application.DuplicatePostRequestException;
import board.application.PostSnapshot;
import board.application.postcreation.CreatePostUseCase.CreatePostCommand;
import jakarta.persistence.EntityManager;
import jakarta.persistence.EntityManagerFactory;
import jakarta.persistence.PersistenceException;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.data.jpa.test.autoconfigure.DataJpaTest;
import org.springframework.context.annotation.Import;
import org.springframework.orm.jpa.JpaTransactionManager;
import org.springframework.test.context.transaction.TestTransaction;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

@DataJpaTest(properties = {
        "spring.jpa.hibernate.ddl-auto=validate",
        "spring.jpa.defer-datasource-initialization=false",
        "spring.sql.init.mode=always",
        "spring.sql.init.schema-locations=classpath:schema.sql",
        "spring.sql.init.data-locations=classpath:jpa-members.sql",
        "spring.datasource.generate-unique-name=true"
})
@Import({JpaPostRepository.class, QuerydslJpaConfiguration.class})
class JpaPostRepositoryTest {
    private static final Instant CREATED_AT =
            Instant.parse("2026-07-14T09:00:00Z");

    @Autowired
    EntityManager entityManager;

    @Autowired
    EntityManagerFactory entityManagerFactory;

    @Autowired
    JpaPostRepository adapter;

    @Autowired
    PlatformTransactionManager transactionManager;

    @Autowired
    DataSource dataSource;

    @Test
    void managed_identity_dirty_check_and_clear_reload_are_distinct() {
        PostEntity entity = PostEntity.create(
                command("jpa-id-01", "JPA", "managed identity"),
                CREATED_AT);
        entityManager.persist(entity);
        entityManager.flush();

        PostEntity same = entityManager.find(PostEntity.class, entity.getId());
        assertThat(same).isSameAs(entity);
        long initialVersion = entity.getVersion();

        entity.changeForPersistenceLesson("JPA 수정", "dirty checking");
        entityManager.flush();
        assertThat(entity.getVersion()).isEqualTo(initialVersion + 1);

        entityManager.clear();
        PostEntity reloaded = entityManager.find(PostEntity.class, entity.getId());
        assertThat(reloaded).isNotSameAs(entity);
        assertThat(reloaded.getContent()).isEqualTo("dirty checking");
    }

    @Test
    void flush_is_not_commit_and_rollback_removes_the_flushed_row() {
        PostEntity entity = PostEntity.create(
                command("jpa-rb-01", "flush", "rollback after flush"),
                CREATED_AT);
        entityManager.persist(entity);
        entityManager.flush();
        long id = entity.getId();
        assertThat(id).isPositive();

        TestTransaction.flagForRollback();
        TestTransaction.end();
        TestTransaction.start();
        entityManager.clear();

        assertThat(entityManager.find(PostEntity.class, id)).isNull();
    }

    @Test
    void application_adapter_preserves_create_update_delete_facts() {
        PostSnapshot created = adapter.create(
                command("jpa-port-01", "port", "shared snapshot"),
                CREATED_AT);

        assertThat(created.id()).isPositive();
        assertThat(created.version()).isZero();
        assertThat(adapter.update(new ChangedPost(
                created.id(), 41L, "changed", "version one", 0L))).isTrue();
        assertThat(adapter.update(new ChangedPost(
                created.id(), 41L, "stale", "must not win", 0L))).isFalse();
        assertThat(adapter.update(new ChangedPost(
                created.id(), 42L, "other", "must not win", 1L))).isFalse();

        PostSnapshot changed = adapter.find(created.id(), 41L).orElseThrow();
        assertThat(changed.content()).isEqualTo("version one");
        assertThat(changed.version()).isEqualTo(1L);
        assertThat(adapter.delete(new DeletePostCommand(
                created.id(), 42L, 1L))).isFalse();
        assertThat(adapter.delete(new DeletePostCommand(
                created.id(), 41L, 1L))).isTrue();
    }

    @Test
    void member_request_constraint_is_the_only_duplicate_classification() {
        CreatePostCommand command =
                command("jpa-dup-01", "first", "original row");
        adapter.create(command, CREATED_AT);

        assertThatThrownBy(() -> adapter.create(command, CREATED_AT.plusSeconds(1)))
                .isInstanceOf(DuplicatePostRequestException.class)
                .satisfies(failure -> assertThat(failure.getCause()).isNotNull());
    }

    @Test
    void jpa_slice_uses_its_jpa_manager_and_the_same_data_source() {
        assertThat(transactionManager).isInstanceOf(JpaTransactionManager.class);
        JpaTransactionManager manager =
                (JpaTransactionManager) transactionManager;
        assertThat(manager.getDataSource()).isSameAs(dataSource);
    }

    @Test
    @Transactional(propagation = Propagation.NOT_SUPPORTED)
    void two_independent_contexts_produce_one_optimistic_conflict() {
        long id = insertCommitted();
        EntityManager first = entityManagerFactory.createEntityManager();
        EntityManager second = entityManagerFactory.createEntityManager();
        try {
            first.getTransaction().begin();
            second.getTransaction().begin();
            PostEntity winner = first.find(PostEntity.class, id);
            PostEntity loser = second.find(PostEntity.class, id);

            winner.changeForPersistenceLesson("winner", "first commit");
            loser.changeForPersistenceLesson("loser", "must conflict");
            first.flush();
            first.getTransaction().commit();

            assertThatThrownBy(second::flush)
                    .isInstanceOf(PersistenceException.class);
        } finally {
            rollbackIfActive(first);
            rollbackIfActive(second);
            first.close();
            second.close();
        }

        EntityManager verification = entityManagerFactory.createEntityManager();
        try {
            PostEntity stored = verification.find(PostEntity.class, id);
            assertThat(stored.getContent()).isEqualTo("first commit");
            assertThat(stored.getVersion()).isEqualTo(1L);
        } finally {
            verification.close();
            deleteCommitted(id);
        }
    }

    private long insertCommitted() {
        EntityManager manager = entityManagerFactory.createEntityManager();
        try {
            manager.getTransaction().begin();
            PostEntity entity = PostEntity.create(
                    command("jpa-lock-01", "initial", "version zero"),
                    CREATED_AT);
            manager.persist(entity);
            manager.flush();
            long id = entity.getId();
            manager.getTransaction().commit();
            return id;
        } finally {
            rollbackIfActive(manager);
            manager.close();
        }
    }

    private void deleteCommitted(long id) {
        EntityManager manager = entityManagerFactory.createEntityManager();
        try {
            manager.getTransaction().begin();
            PostEntity stored = manager.find(PostEntity.class, id);
            if (stored != null) {
                manager.remove(stored);
            }
            manager.getTransaction().commit();
        } finally {
            rollbackIfActive(manager);
            manager.close();
        }
    }

    private static void rollbackIfActive(EntityManager manager) {
        if (manager.getTransaction().isActive()) {
            manager.getTransaction().rollback();
        }
    }

    private static CreatePostCommand command(
            String requestId,
            String title,
            String content
    ) {
        return new CreatePostCommand(
                41L,
                title,
                content,
                LocalDate.parse("2026-07-14"),
                requestId);
    }
}

package board.jpa;

record OptimisticConflict(
        long postId,
        long expectedVersion
) {
    public OptimisticConflict {
        if (postId <= 0 || expectedVersion < 0) {
            throw new IllegalArgumentException("invalid conflict context");
        }
    }
}