트랜잭션 관리자

package board.config;

import javax.sql.DataSource;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;
import org.springframework.transaction.support.TransactionTemplate;

@Configuration(proxyBeanMethods = false)
@EnableTransactionManagement
public class JdbcTransactionConfiguration {
    @Bean
    PlatformTransactionManager transactionManager(DataSource dataSource) {
        var manager = new DataSourceTransactionManager(dataSource);
        manager.setEnforceReadOnly(true);
        return manager;
    }

    @Bean
    TransactionTemplate transactionTemplate(
            PlatformTransactionManager transactionManager
    ) {
        var template = new TransactionTemplate(transactionManager);
        template.setTimeout(5);
        return template;
    }

    @Bean
    TransactionPolicies transactionPolicies(
            PlatformTransactionManager transactionManager
    ) {
        return TransactionPolicies.from(transactionManager);
    }
}

package board.application;

import java.time.LocalDate;

public interface DailyPostRepository {
    Reservation reserve(
            long memberId,
            LocalDate publishedOn,
            int attemptedCharacters
    );

    record Reservation(
            int limitCharacters,
            int usedCharacters,
            int attemptedCharacters,
            boolean accepted
    ) {
        public Reservation {
            if (limitCharacters < 1
                    || usedCharacters < 0
                    || attemptedCharacters < 1) {
                throw new IllegalArgumentException("invalid reservation");
            }
            boolean withinLimit = (long) usedCharacters
                    + attemptedCharacters <= limitCharacters;
            if (accepted != withinLimit) {
                throw new IllegalArgumentException(
                        "accepted must match the character limit");
            }
        }
    }
}

package board.application;

import java.time.Instant;

import board.application.postcreation.CreatePostUseCase.CreatePostCommand;

public interface PostRepository {
    long insert(CreatePostCommand command, Instant createdAt);

    PostSummary summary(long memberId);
}

package board.application;

public record PostSummary(
        long memberId,
        long postCount,
        long totalCharacters
) {
    public PostSummary {
        if (memberId <= 0 || postCount < 0 || totalCharacters < 0) {
            throw new IllegalArgumentException("invalid post summary");
        }
    }
}

package board.application;

import java.time.Clock;
import java.time.Instant;

import board.application.postcreation.CreatePostUseCase.CreatePostCommand;
import board.application.postcreation.DailyLimitExceededException;

import org.springframework.stereotype.Service;
import org.springframework.transaction.support.TransactionTemplate;

@Service
public final class TemplatePostService {
    private final TransactionTemplate transactions;
    private final DailyPostRepository daily;
    private final PostRepository posts;
    private final Clock clock;

    public TemplatePostService(
            TransactionTemplate transactions,
            DailyPostRepository daily,
            PostRepository posts,
            Clock clock
    ) {
        this.transactions = transactions;
        this.daily = daily;
        this.posts = posts;
        this.clock = clock;
    }

    public long register(CreatePostCommand command) {
        Long result = transactions.execute(status -> {
            var reservation = daily.reserve(
                    command.memberId(),
                    command.publishedOn(),
                    command.content().length());
            if (!reservation.accepted()) {
                throw new DailyLimitExceededException(
                        reservation.limitCharacters(),
                        reservation.usedCharacters(),
                        reservation.attemptedCharacters());
            }
            Instant createdAt = clock.instant();
            return posts.insert(command, createdAt);
        });
        if (result == null) {
            throw new IllegalStateException(
                    "transaction callback returned null");
        }
        return result;
    }
}

package board.jdbc;

import java.sql.Date;
import java.sql.SQLException;
import java.time.Instant;
import java.time.OffsetDateTime;
import java.time.ZoneOffset;
import java.util.Objects;

import javax.sql.DataSource;

import board.application.postcreation.CreatePostUseCase.CreatePostCommand;

import org.springframework.jdbc.datasource.DataSourceUtils;

public final class TransactionAwarePostInsert {
    private final DataSource dataSource;

    public TransactionAwarePostInsert(DataSource dataSource) {
        this.dataSource = Objects.requireNonNull(dataSource, "dataSource");
    }

    public long insert(CreatePostCommand command, Instant createdAt) {
        Objects.requireNonNull(command, "command");
        Objects.requireNonNull(createdAt, "createdAt");
        var connection = DataSourceUtils.getConnection(dataSource);
        try (var statement = connection.prepareStatement(
                """
                insert into posts(
                    member_id, title, content, published_on,
                    client_request_id, created_at, version)
                values (?, ?, ?, ?, ?, ?, 0)
                """,
                java.sql.Statement.RETURN_GENERATED_KEYS)) {
            statement.setLong(1, command.memberId());
            statement.setString(2, command.title());
            statement.setString(3, command.content());
            statement.setDate(4, Date.valueOf(command.publishedOn()));
            statement.setString(5, command.clientRequestId());
            statement.setObject(6, OffsetDateTime.ofInstant(
                    createdAt, ZoneOffset.UTC));
            statement.executeUpdate();
            try (var keys = statement.getGeneratedKeys()) {
                if (!keys.next()) {
                    throw new SQLException("generated key missing");
                }
                return keys.getLong(1);
            }
        } catch (SQLException exception) {
            throw new PostPersistenceException(exception);
        } finally {
            DataSourceUtils.releaseConnection(connection, dataSource);
        }
    }

    public static final class PostPersistenceException
            extends RuntimeException {
        public PostPersistenceException(SQLException cause) {
            super("failed to insert post", cause);
        }
    }
}

package board.application;

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

import java.time.Clock;
import java.time.Instant;
import java.time.LocalDate;
import java.time.OffsetDateTime;
import java.time.ZoneOffset;

import javax.sql.DataSource;

import board.application.postcreation.CreatePostUseCase.CreatePostCommand;
import board.application.postcreation.DailyLimitExceededException;
import board.config.JdbcTransactionConfiguration;
import board.config.TransactionPolicies;
import board.jdbc.TransactionAwarePostInsert;

import org.h2.jdbcx.JdbcDataSource;
import org.junit.jupiter.api.Test;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.core.io.ClassPathResource;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.jdbc.datasource.init.ResourceDatabasePopulator;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.support.TransactionSynchronizationManager;
import org.springframework.transaction.support.TransactionTemplate;

class TransactionTemplateRollbackTest {
    @Test
    void 구성은_하나의_manager와_고정된_template_정책을_제공한다() {
        try (var context = context(dataSource("manager"))) {
            assertThat(context.getBean(PlatformTransactionManager.class))
                    .isInstanceOf(DataSourceTransactionManager.class);
            assertThat(context.getBean(TransactionTemplate.class).getTimeout())
                    .isEqualTo(5);

            var policies = context.getBean(TransactionPolicies.class);
            assertThat(policies.query().isReadOnly()).isTrue();
            assertThat(policies.query().getTimeout()).isEqualTo(5);
            assertThat(policies.command().isReadOnly()).isFalse();
            assertThat(policies.command().getTimeout()).isEqualTo(3);
        }
    }

    @Test
    void transaction_aware_insert는_같은_connection에_참여하고_rollback한다() {
        DataSource dataSource = initializedDataSource("aware_insert");
        var jdbc = new JdbcTemplate(dataSource);
        insertMember(jdbc);
        var transactions = new TransactionTemplate(
                new DataSourceTransactionManager(dataSource));
        var insert = new TransactionAwarePostInsert(dataSource);
        var command = command("transaction-aware-0001", "본문");

        assertThatThrownBy(() -> transactions.execute(status -> {
            assertThat(TransactionSynchronizationManager.hasResource(dataSource))
                    .isTrue();
            long postId = insert.insert(
                    command, Instant.parse("2026-08-29T03:00:00Z"));
            assertThat(jdbc.queryForObject(
                    "select member_id from posts where id = ?",
                    Long.class,
                    postId)).isEqualTo(41L);
            assertThat(jdbc.queryForObject(
                    "select published_on from posts where id = ?",
                    LocalDate.class,
                    postId)).isEqualTo(LocalDate.of(2026, 8, 29));
            assertThat(jdbc.queryForObject(
                    "select client_request_id from posts where id = ?",
                    String.class,
                    postId)).isEqualTo("transaction-aware-0001");
            assertThat(jdbc.queryForObject(
                    "select created_at from posts where id = ?",
                    OffsetDateTime.class,
                    postId).toInstant()).isEqualTo(
                            Instant.parse("2026-08-29T03:00:00Z"));
            assertThat(jdbc.queryForObject(
                    "select version from posts where id = ?",
                    Long.class,
                    postId)).isZero();
            throw new IllegalStateException("second operation failed");
        })).isInstanceOf(IllegalStateException.class)
                .hasMessage("second operation failed");

        Integer count = jdbc.queryForObject(
                "select count(*) from posts", Integer.class);
        assertThat(count).isZero();
        assertThat(TransactionSynchronizationManager.hasResource(dataSource))
                .isFalse();
    }

    @Test
    void 게시일별_한도_거부는_upstream_exception의_정확한_수치를_보존한다() {
        DataSource dataSource = dataSource("limit_rejected");
        var transactions = new TransactionTemplate(
                new DataSourceTransactionManager(dataSource));
        DailyPostRepository daily = (memberId, publishedOn, attempted) ->
                new DailyPostRepository.Reservation(
                        720, 701, attempted, false);
        PostRepository posts = new PostRepository() {
            @Override
            public long insert(CreatePostCommand command, Instant createdAt) {
                throw new AssertionError("insert must not be called");
            }

            @Override
            public PostSummary summary(long memberId) {
                throw new UnsupportedOperationException();
            }
        };
        var service = new TemplatePostService(
                transactions,
                daily,
                posts,
                Clock.fixed(
                        Instant.parse("2026-08-29T03:00:00Z"),
                        ZoneOffset.UTC));

        assertThatThrownBy(() -> service.register(command(
                "transaction-limit-0001", "12345678901234567890")))
                .isInstanceOfSatisfying(
                        DailyLimitExceededException.class,
                        exception -> {
                            assertThat(exception.limitCharacters())
                                    .isEqualTo(720);
                            assertThat(exception.usedCharacters())
                                    .isEqualTo(701);
                            assertThat(exception.attemptedCharacters())
                                    .isEqualTo(20);
                        });
    }

    private AnnotationConfigApplicationContext context(DataSource dataSource) {
        var context = new AnnotationConfigApplicationContext();
        context.registerBean(DataSource.class, () -> dataSource);
        context.register(JdbcTransactionConfiguration.class);
        context.refresh();
        return context;
    }

    private DataSource initializedDataSource(String name) {
        DataSource dataSource = dataSource(name);
        new ResourceDatabasePopulator(new ClassPathResource("schema.sql"))
                .execute(dataSource);
        return dataSource;
    }

    private DataSource dataSource(String name) {
        var dataSource = new JdbcDataSource();
        dataSource.setURL("jdbc:h2:mem:" + name
                + ";MODE=PostgreSQL;DB_CLOSE_DELAY=-1");
        dataSource.setUser("sa");
        return dataSource;
    }

    private void insertMember(JdbcTemplate jdbc) {
        jdbc.update(
                """
                insert into members(
                    id, email, password_hash, name,
                    active, daily_character_limit)
                values (41, '[email protected]', 'hash', '회원', true, 720)
                """);
    }

    private CreatePostCommand command(String requestId, String content) {
        return new CreatePostCommand(
                41L,
                "트랜잭션 경계",
                content,
                LocalDate.of(2026, 8, 29),
                requestId);
    }
}