@Transactional 프록시

package board.tx.proxy.boundary;

import javax.sql.DataSource;

import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.support.TransactionSynchronizationManager;

public class BoardTransactionService {
    private final DataSource boardDataSource;
    private final DataSource auditDataSource;
    private final JdbcTemplate boardJdbc;

    public BoardTransactionService(
            @Qualifier("boardDataSource") DataSource boardDataSource,
            @Qualifier("auditDataSource") DataSource auditDataSource
    ) {
        this.boardDataSource = boardDataSource;
        this.auditDataSource = auditDataSource;
        this.boardJdbc = new JdbcTemplate(boardDataSource);
    }

    @Transactional(transactionManager = "boardTransactionManager")
    public Observation register(long id, String title) {
        boardJdbc.update(
                "insert into proxy_post(id, title) values (?, ?)",
                id,
                title
        );
        return new Observation(
                TransactionSynchronizationManager.isActualTransactionActive(),
                TransactionSynchronizationManager.hasResource(boardDataSource),
                TransactionSynchronizationManager.hasResource(auditDataSource),
                TransactionSynchronizationManager.getCurrentTransactionName()
        );
    }

    public record Observation(
            boolean transactionActive,
            boolean boardResourceBound,
            boolean auditResourceBound,
            String transactionName
    ) { }
}

package board.tx.proxy.boundary;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertTrue;

import javax.sql.DataSource;

import org.h2.jdbcx.JdbcDataSource;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.aop.support.AopUtils;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;
import org.springframework.transaction.support.TransactionSynchronizationManager;

class TransactionBoundaryTest {
    private AnnotationConfigApplicationContext context;
    private JdbcTemplate boardJdbc;
    private JdbcTemplate auditJdbc;

    @BeforeEach
    void openContext() {
        context = new AnnotationConfigApplicationContext(BoundaryConfig.class);
        boardJdbc = new JdbcTemplate(context.getBean("boardDataSource", DataSource.class));
        auditJdbc = new JdbcTemplate(context.getBean("auditDataSource", DataSource.class));
        boardJdbc.execute("create table if not exists proxy_post(id bigint primary key, title varchar(120) not null)");
        auditJdbc.execute("create table if not exists proxy_audit(id bigint primary key)");
        boardJdbc.update("delete from proxy_post");
        auditJdbc.update("delete from proxy_audit");
    }

    @AfterEach
    void closeContext() {
        context.close();
    }

    @Test
    void proxy_entry_starts_and_completes_the_transaction() {
        var service = context.getBean(BoardTransactionService.class);

        assertTrue(AopUtils.isAopProxy(service));
        assertFalse(TransactionSynchronizationManager.isActualTransactionActive());

        var observation = service.register(41L, "proxy boundary");

        assertTrue(observation.transactionActive());
        assertTrue(observation.boardResourceBound());
        assertNotNull(observation.transactionName());
        assertTrue(observation.transactionName().endsWith(".register"));
        assertFalse(TransactionSynchronizationManager.isActualTransactionActive());
        assertEquals(1, boardJdbc.queryForObject(
                "select count(*) from proxy_post",
                Integer.class
        ));
    }

    @Test
    void named_manager_binds_only_its_owned_data_source() {
        var service = context.getBean(BoardTransactionService.class);

        var observation = service.register(42L, "resource ownership");

        assertTrue(observation.boardResourceBound());
        assertFalse(observation.auditResourceBound());
        assertEquals(0, auditJdbc.queryForObject(
                "select count(*) from proxy_audit",
                Integer.class
        ));
    }

    @Configuration(proxyBeanMethods = false)
    @EnableTransactionManagement(proxyTargetClass = true)
    static class BoundaryConfig {
        @Bean("boardDataSource")
        DataSource boardDataSource() {
            return dataSource("b92_proxy_boundary_board");
        }

        @Bean("auditDataSource")
        DataSource auditDataSource() {
            return dataSource("b92_proxy_boundary_audit");
        }

        @Bean("boardTransactionManager")
        PlatformTransactionManager boardTransactionManager(
                @Qualifier("boardDataSource") DataSource dataSource
        ) {
            return new DataSourceTransactionManager(dataSource);
        }

        @Bean("auditTransactionManager")
        PlatformTransactionManager auditTransactionManager(
                @Qualifier("auditDataSource") DataSource dataSource
        ) {
            return new DataSourceTransactionManager(dataSource);
        }

        @Bean
        BoardTransactionService boardTransactionService(
                @Qualifier("boardDataSource") DataSource boardDataSource,
                @Qualifier("auditDataSource") DataSource auditDataSource
        ) {
            return new BoardTransactionService(boardDataSource, auditDataSource);
        }

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