17 트랜잭션

p296 - src/main/java/spring/domain/Account

@Data
public class Account {
    private String name;
    private int amount;
}

p297, 298 - src/main/java/spring/jdbc/repository/AccountRepository

public class AccountRepository {
    // 잔액 조회 메서드
    public Account findByName(Connection connection, String name) throws SQLException {
        String sql = "SELECT name, amount FROM Account WHERE name = ?";
        PreparedStatement pstmt = connection.prepareStatement(sql);
        pstmt.setString(1, name);

        ResultSet rs = null;
        try {
            rs = pstmt.executeQuery();
            if (rs.next()) {
                Account account = new Account();
                account.setName(rs.getString("name"));
                account.setAmount(rs.getInt("amount"));
                return account;
            } else {
                throw new RuntimeException("Account not found: " + name);
            }
        } finally {
            if (rs != null) {
                rs.close();
            }
            pstmt.close();
        }
    }

    // 출금 메서드
    public void withdraw(Connection connection, String name, int amount) throws SQLException {
        Account account = findByName(connection, name);
        if (account.getAmount() < amount) {
            throw new RuntimeException("Insufficient balance");
        }

        String sql = "UPDATE Account SET amount = amount - ? WHERE name = ?";
        PreparedStatement pstmt = connection.prepareStatement(sql);
        try {
            pstmt.setInt(1, amount);
            pstmt.setString(2, name);
            pstmt.executeUpdate();
        } finally {
            pstmt.close();
        }
    }

    // 입금 메서드
    public void deposit(Connection connection, String name, int amount) throws SQLException {
        String sql = "UPDATE Account SET amount = amount + ? WHERE name = ?";
        PreparedStatement pstmt = connection.prepareStatement(sql);
        try {
            pstmt.setInt(1, amount);
            pstmt.setString(2, name);
            pstmt.executeUpdate();
        } finally {
            pstmt.close();
        }
    }

    // 계좌 생성 메서드
    public void createAccount(Connection connection, String name, int amount) throws SQLException {
        String sql = "INSERT INTO Account (name, amount) VALUES (?, ?)";
        PreparedStatement pstmt = connection.prepareStatement(sql);
        try {
            pstmt.setString(1, name);
            pstmt.setInt(2, amount);
            pstmt.executeUpdate();
        } finally {
            pstmt.close();
        }
    }

    // 계좌 삭제 메서드
    public void deleteAccount(Connection connection, String name) throws SQLException {
        String sql = "DELETE FROM Account WHERE name = ?";
        PreparedStatement pstmt = connection.prepareStatement(sql);
        try {
            pstmt.setString(1, name);
            pstmt.executeUpdate();
        } finally {
            pstmt.close();
        }
    }
}

p299, 300 - src/main/java/spring/jdbc/service/AccountService

@Slf4j
public class AccountService {

    private final DataSource dataSource;
    private final AccountRepository accountRepository;

    public AccountService(DataSource dataSource, AccountRepository accountRepository) {
        this.dataSource = dataSource;
        this.accountRepository = accountRepository;
    }

    public void transferMoney(String fromName, String toName, int amount) throws SQLException {
        Connection connection = null;
        try {
            connection = dataSource.getConnection();
            connection.setAutoCommit(false); // 트랜잭션 시작

            // 출금
            accountRepository.withdraw(connection, fromName, amount);

            log.info("Trasnsaction started for: {}", fromName);
            // 인위적인 지연을 추가하여 트랜잭션 경합 발생 가능성 증가
            // 입금
            accountRepository.deposit(connection, toName, amount);

            // 트랜잭션 커밋
            connection.commit();

        } catch (SQLTimeoutException e) {
            // SQL 타임아웃이 발생하면 락이 걸린 상태로 대기 중일 수 있음
            log.info("Lock timeout occurred: " + e.getMessage());
        } catch (SQLException e) {
            log.info("SQLException occurred: " + e.getMessage());
            if (connection != null) {
                connection.rollback(); // 오류 발생 시 트랜잭션 롤백
            }
        } finally {
            if (connection != null) {
                connection.setAutoCommit(true); // 원래 상태로 복구
                connection.close(); // 커넥션 닫기
            }
        }
    }

    public void transferMoneyWithDelay(String fromName, String toName, int amount) throws SQLException {
        Connection connection = null;
        try {
            connection = dataSource.getConnection();
            connection.setAutoCommit(false); // 트랜잭션 시작

            // 출금
            accountRepository.withdraw(connection, fromName, amount);

            log.info("Trasnsaction started for: {}", fromName);

            // 인위적으로 지연을 추가하여 락을 유지한 상태로 둠
            Thread.sleep(5000);  // 5초 대기

            // 입금
            accountRepository.deposit(connection, toName, amount);

            // 트랜잭션 커밋
            connection.commit();

        } catch (SQLTimeoutException e) {
            // SQL 타임아웃이 발생하면 락이 걸린 상태로 대기 중일 수 있음
            log.info("Lock timeout occurred: " + e.getMessage());
        } catch (SQLException e) {
            log.info("SQLException occurred: " + e.getMessage());
            if (connection != null) {
                connection.rollback(); // 오류 발생 시 트랜잭션 롤백
            }
        } catch (InterruptedException e) {
            log.info("InterruptedException occured: " + e.getMessage());
        } finally {
            if (connection != null) {
                connection.setAutoCommit(true); // 원래 상태로 복구
                connection.close(); // 커넥션 닫기
            }
        }
    }

    // 트랜잭션 실패 시 롤백이 이루어지지 않는 상황을 시뮬레이션
    public void transferMoneyWithoutRollback(String fromName, String toName, int amount) throws SQLException {
        Connection connection = null;
        try {
            connection = dataSource.getConnection();
            // 출금 (성공적으로 처리됨)
            accountRepository.withdraw(connection, fromName, amount);

            // 인위적인 예외 발생 (입금 중 예외 발생)
            if (true) {
                throw new RuntimeException("Error during deposit operation");
            }

            // 입금 (실행되지 않음)
            accountRepository.deposit(connection, toName, amount);

        } catch (Exception e) {
            log.info("Exception occurred: " + e.getMessage());
            // 롤백을 수행하지 않음
        } finally {
            if (connection != null) {
                connection.close(); // 커넥션 닫기
            }
        }
    }

    // 새로운 메서드 추가: 계좌 조회 서비스 로직
    public Account findAccountByName(String name) {
        Connection connection = null;
        try {
            connection = dataSource.getConnection();
            return accountRepository.findByName(connection, name);
        } catch (SQLException e) {
            log.info("SQLException occurred while finding account: " + e.getMessage());
            throw new RuntimeException("Error occurred while fetching account: " + name, e);
        } finally {
            if (connection != null) {
                try {
                    connection.close(); // 커넥션 닫기
                } catch (SQLException e) {
                    log.info("Failed to close connection: " + e.getMessage());
                }
            }
        }
    }
}

p301, 302 - src/test/java/spring/jdbc/service/AccountServiceTest

@Slf4j
class AccountServiceTest {

    private static final String URL = "jdbc:mysql://localhost:3306/test";
    private static final String USERNAME = "root";
    private static final String PASSWORD = "1234";

    private DataSource dataSource;
    private AccountRepository accountRepository;
    private AccountService accountService;

    @BeforeEach
    public void setUp() throws SQLException {
        // HikariCP 설정 및 MySQL 연결
        HikariConfig config = new HikariConfig();
        config.setJdbcUrl(URL);
        config.setUsername(USERNAME);
        config.setPassword(PASSWORD);
        dataSource = new HikariDataSource(config);

        // Repository 및 Service 인스턴스 초기화
        accountRepository = new AccountRepository();
        accountService = new AccountService(dataSource, accountRepository);

        // 계좌 및 유저 생성
        try (Connection connection = dataSource.getConnection()) {
            connection.setAutoCommit(false); // 트랜잭션 시작
            // 계좌가 이미 있으면 삭제 후 생성
            accountRepository.deleteAccount(connection, "AccountA");
            accountRepository.deleteAccount(connection, "AccountB");
            accountRepository.createAccount(connection, "AccountA", 1000);
            accountRepository.createAccount(connection, "AccountB", 1000);
            connection.commit();
        }
    }

    @AfterEach
    public void tearDown() throws SQLException {
        // 테스트 후 계좌 초기화
        try (Connection connection = dataSource.getConnection()) {
            connection.setAutoCommit(false); // 트랜잭션 시작
            // 계좌 삭제
            accountRepository.deleteAccount(connection, "AccountA");
            accountRepository.deleteAccount(connection, "AccountB");
            connection.commit();
        }
    }

    @Test
    public void testConcurrentTransactionIssue() throws InterruptedException {
        // 스레드 1: 계좌 A에서 B로 송금
        Thread thread1 = new Thread(() -> {
            try {
                accountService.transferMoney("AccountA", "AccountB", 500);
            } catch (SQLException e) {
                System.out.println("Thread 1 Error: " + e.getMessage());
            }
        });

        // 스레드 2: 계좌 A에서 B로 동시에 송금 (동일한 자원 접근)
        Thread thread2 = new Thread(() -> {
            try {
                accountService.transferMoney("AccountA", "AccountB", 500);
            } catch (SQLException e) {
                System.out.println("Thread 2 Error: " + e.getMessage());
            }
        });

        // 두 스레드를 거의 동시에 시작
        thread1.start();
        thread2.start();

        // 두 스레드가 끝날 때까지 기다림
        thread1.join();
        thread2.join();

        try {
            Account accountA = accountService.findAccountByName("AccountA");
            Account accountB = accountService.findAccountByName("AccountB");
            assertEquals(0, accountA.getAmount());  // AccountA는 0이어야 함
            assertEquals(2000, accountB.getAmount());  // AccountB는 2000이어야 함
        } catch (Exception e) {
            fail("Database error: " + e.getMessage());
        }
    }

    @Test
    public void testTransactionLockIssue() throws InterruptedException {
        // 스레드 1: 계좌 A에서 B로 송금 (트랜잭션 지연)
        Thread thread1 = new Thread(() -> {
            try {
                accountService.transferMoneyWithDelay("AccountA", "AccountB", 500);
            } catch (SQLException e) {
                System.out.println("Thread 1 Error: " + e.getMessage());
            }
        });

        // 스레드 2: 계좌 A에서 B로 동시에 송금 (락이 걸린 상태로 접근 시도)
        Thread thread2 = new Thread(() -> {
            try {
                accountService.transferMoneyWithDelay("AccountA", "AccountB", 500);
            } catch (SQLException e) {
                System.out.println("Thread 2 Error: " + e.getMessage());
            }
        });

        // 두 스레드를 거의 동시에 시작
        thread1.start();
        thread2.start();

        // 두 스레드가 끝날 때까지 기다림
        thread1.join();
        thread2.join();

        // 결과 확인: AccountA 잔액 확인 (트랜잭션이 실패하면 그대로 남아있어야 함)
        try {
            Account accountA = accountService.findAccountByName("AccountA");
            Account accountB = accountService.findAccountByName("AccountB");
            log.info("accountA getAmout : {}", accountA.getAmount());
            log.info("accountB getAmount : {}", accountB.getAmount());
            // 두 트랜잭션이 충돌했기 때문에 AccountA의 잔액이 0이 아닐 수도 있음
            assertTrue(accountA.getAmount() >= 0 && accountA.getAmount() <= 1000);
            assertTrue(accountB.getAmount() >= 1000 && accountB.getAmount() <= 2000);
        } catch (Exception e) {
            fail("Database error: " + e.getMessage());
        }
    }

    @Test
    public void testPartialCommitWithoutRollback() throws InterruptedException, SQLException {
        // 트랜잭션이 정상적으로 롤백되지 않는 상황을 테스트

        // 출금 후 예외 발생으로 입금은 되지 않지만, 롤백이 발생하지 않음
        try {
            accountService.transferMoneyWithoutRollback("AccountA", "AccountB", 500);
        } catch (Exception e) {
            System.out.println("Exception caught in test: " + e.getMessage());
        }

        // 결과 확인: AccountA에서 500이 인출되고, AccountB는 변동이 없어야 함
        try {
            Account accountA = accountService.findAccountByName("AccountA");
            Account accountB = accountService.findAccountByName("AccountB");
            assertEquals(500, accountA.getAmount());  // AccountA에서는 500이 빠져 있어야 함
            assertEquals(1000, accountB.getAmount());  // AccountB는 변화가 없어야 함 (입금 실패)
        } catch (Exception e) {
            fail("Database error: " + e.getMessage());
        }
    }
}

p303, 304, - src/main/java/spring/jdbc/repository/AccountRepositoryTransactionManager

@Slf4j
public class AccountServiceTransactionManager {

    private final PlatformTransactionManager transactionManager;
    private final AccountRepositoryTransactionManager accountRepositoryTransactionManager;

    public AccountServiceTransactionManager(PlatformTransactionManager transactionManager, AccountRepositoryTransactionManager accountRepositoryTransactionManager) {
        this.transactionManager = transactionManager;
        this.accountRepositoryTransactionManager = accountRepositoryTransactionManager;
    }

    public void transferMoney(String fromName, String toName, int amount) throws SQLException {
        // 트랜잭션 시작
        TransactionStatus status = transactionManager.getTransaction(new DefaultTransactionDefinition());

        try {
            // 출금
            accountRepositoryTransactionManager.withdraw(fromName, amount);
            log.info("Transaction started for: {}", fromName);

            // 입금
            accountRepositoryTransactionManager.deposit(toName, amount);

            // 트랜잭션 커밋
            transactionManager.commit(status);
            log.info("Transaction committed for: {} -> {}", fromName, toName);

        } catch (Exception e) {
            // 트랜잭션 롤백
            transactionManager.rollback(status);
            log.error("Transaction rolled back due to an error: {}", e.getMessage());
            throw e; // 예외 재발생
        }
    }

    @Transactional
    public void transferMoneyTransactional(String fromName, String toName, int amount) throws SQLException {
        // 출금
        accountRepositoryTransactionManager.withdraw(fromName, amount);
        log.info("Transaction started for: {}", fromName);

        // 입금
        accountRepositoryTransactionManager.deposit(toName, amount);
    }

    @Transactional
    public void transferMoneyTransactionalError(String fromName, String toName, int amount) throws SQLException {
        // 출금
        accountRepositoryTransactionManager.withdraw(fromName, amount);
        log.info("Transaction started for: {}", fromName);
        throw new RuntimeException("exception");
        // 입금
//        accountRepositoryTransactionManager.deposit(toName, amount);
    }

    public void transferMoneyWithDelay(String fromName, String toName, int amount) throws SQLException, InterruptedException {

        TransactionStatus status = transactionManager.getTransaction(new DefaultTransactionDefinition());

        try {
            // 출금
            accountRepositoryTransactionManager.withdraw(fromName, amount);
            log.info("Transaction started for: {}", fromName);

            // 인위적인 지연
            Thread.sleep(5000); // 5초 대기

            // 입금
            accountRepositoryTransactionManager.deposit(toName, amount);

            // 트랜잭션 커밋
            transactionManager.commit(status);
            log.info("Transaction committed for: {} -> {}", fromName, toName);

        } catch (Exception e) {
            transactionManager.rollback(status);
            log.error("Transaction rolled back due to an error: {}", e.getMessage());
            throw e;
        }
    }

    public Account findAccountByName(String name) throws SQLException {

        TransactionStatus status = transactionManager.getTransaction(new DefaultTransactionDefinition());

        try {
            // 계좌 조회
            Account account = accountRepositoryTransactionManager.findByName(name);
            transactionManager.commit(status);
            return account;
        } catch (Exception e) {
            transactionManager.rollback(status);
            log.error("Transaction rolled back due to an error: {}", e.getMessage());
            throw e;
        }
    }
}

p309 - src/main/java/spring/jdbc/repository/AccountRepositoryTransactionManager

public class AccountRepositoryTransactionManager {
    private final DataSource dataSource;

    public AccountRepositoryTransactionManager(DataSource dataSource) {
        this.dataSource = dataSource;
    }

    // 공통 PreparedStatement 생성 메서드
    private PreparedStatement createPreparedStatement(Connection connection, String sql) throws SQLException {
        return connection.prepareStatement(sql);
    }

    // 자원 해제 공통 메서드
    private void closeResources(ResultSet rs, PreparedStatement pstmt, Connection connection) {
        if (rs != null) {
            try {
                rs.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (pstmt != null) {
            try {
                pstmt.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (connection != null) {
            DataSourceUtils.releaseConnection(connection, dataSource); // 커넥션 해제
        }
    }

    // 잔액 조회 메서드
    public Account findByName(String name) throws SQLException {
        String sql = "SELECT name, amount FROM Account WHERE name = ?";
        Connection connection = DataSourceUtils.getConnection(dataSource);
        PreparedStatement pstmt = null;
        ResultSet rs = null;

        try {
            pstmt = createPreparedStatement(connection, sql);
            pstmt.setString(1, name); // 파라미터 설정을 여기서 처리
            rs = pstmt.executeQuery();
            if (rs.next()) {
                Account account = new Account();
                account.setName(rs.getString("name"));
                account.setAmount(rs.getInt("amount"));
                return account;
            } else {
                throw new RuntimeException("Account not found: " + name);
            }
        } finally {
            closeResources(rs, pstmt, connection);
        }
    }

    // 출금 메서드
    public void withdraw(String name, int amount) throws SQLException {
        Account account = findByName(name);
        if (account.getAmount() < amount) {
            throw new RuntimeException("Insufficient balance");
        }

        String sql = "UPDATE Account SET amount = amount - ? WHERE name = ?";
        Connection connection = DataSourceUtils.getConnection(dataSource);
        PreparedStatement pstmt = null;

        try {
            pstmt = createPreparedStatement(connection, sql);
            pstmt.setInt(1, amount); // 파라미터 설정을 여기서 처리
            pstmt.setString(2, name);
            pstmt.executeUpdate();
        } finally {
            closeResources(null, pstmt, connection);
        }
    }

    // 입금 메서드
    public void deposit(String name, int amount) throws SQLException {
        String sql = "UPDATE Account SET amount = amount + ? WHERE name = ?";
        Connection connection = DataSourceUtils.getConnection(dataSource);
        PreparedStatement pstmt = null;

        try {
            pstmt = createPreparedStatement(connection, sql);
            pstmt.setInt(1, amount); // 파라미터 설정을 여기서 처리
            pstmt.setString(2, name);
            pstmt.executeUpdate();
        } finally {
            closeResources(null, pstmt, connection);
        }
    }

    // 계좌 생성 메서드
    public void createAccount(String name, int amount) throws SQLException {
        String sql = "INSERT INTO Account (name, amount) VALUES (?, ?)";
        Connection connection = DataSourceUtils.getConnection(dataSource);
        PreparedStatement pstmt = null;

        try {
            pstmt = createPreparedStatement(connection, sql);
            pstmt.setString(1, name); // 파라미터 설정을 여기서 처리
            pstmt.setInt(2, amount);
            pstmt.executeUpdate();
        } finally {
            closeResources(null, pstmt, connection);
        }
    }

    // 계좌 삭제 메서드
    public void deleteAccount(String name) throws SQLException {
        String sql = "DELETE FROM Account WHERE name = ?";
        Connection connection = DataSourceUtils.getConnection(dataSource);
        PreparedStatement pstmt = null;

        try {
            pstmt = createPreparedStatement(connection, sql);
            pstmt.setString(1, name); // 파라미터 설정을 여기서 처리
            pstmt.executeUpdate();
        } finally {
            closeResources(null, pstmt, connection);
        }
    }
}

p310 - src/main/java/spring/jdbc/repository/AccountRepository

public class AccountRepository {
    // 잔액 조회 메서드
    public Account findByName(Connection connection, String name) throws SQLException {
        String sql = "SELECT name, amount FROM Account WHERE name = ?";
        PreparedStatement pstmt = connection.prepareStatement(sql);
        pstmt.setString(1, name);

        ResultSet rs = null;
        try {
            rs = pstmt.executeQuery();
            if (rs.next()) {
                Account account = new Account();
                account.setName(rs.getString("name"));
                account.setAmount(rs.getInt("amount"));
                return account;
            } else {
                throw new RuntimeException("Account not found: " + name);
            }
        } finally {
            if (rs != null) {
                rs.close();
            }
            pstmt.close();
        }
    }

    // 출금 메서드
    public void withdraw(Connection connection, String name, int amount) throws SQLException {
        Account account = findByName(connection, name);
        if (account.getAmount() < amount) {
            throw new RuntimeException("Insufficient balance");
        }

        String sql = "UPDATE Account SET amount = amount - ? WHERE name = ?";
        PreparedStatement pstmt = connection.prepareStatement(sql);
        try {
            pstmt.setInt(1, amount);
            pstmt.setString(2, name);
            pstmt.executeUpdate();
        } finally {
            pstmt.close();
        }
    }

    // 입금 메서드
    public void deposit(Connection connection, String name, int amount) throws SQLException {
        String sql = "UPDATE Account SET amount = amount + ? WHERE name = ?";
        PreparedStatement pstmt = connection.prepareStatement(sql);
        try {
            pstmt.setInt(1, amount);
            pstmt.setString(2, name);
            pstmt.executeUpdate();
        } finally {
            pstmt.close();
        }
    }

    // 계좌 생성 메서드
    public void createAccount(Connection connection, String name, int amount) throws SQLException {
        String sql = "INSERT INTO Account (name, amount) VALUES (?, ?)";
        PreparedStatement pstmt = connection.prepareStatement(sql);
        try {
            pstmt.setString(1, name);
            pstmt.setInt(2, amount);
            pstmt.executeUpdate();
        } finally {
            pstmt.close();
        }
    }

    // 계좌 삭제 메서드
    public void deleteAccount(Connection connection, String name) throws SQLException {
        String sql = "DELETE FROM Account WHERE name = ?";
        PreparedStatement pstmt = connection.prepareStatement(sql);
        try {
            pstmt.setString(1, name);
            pstmt.executeUpdate();
        } finally {
            pstmt.close();
        }
    }
}

p311, 312, - src/main/java/spring/jdbc/service/AccountServiceTransactionManager

@Slf4j
public class AccountServiceTransactionManager {

    private final PlatformTransactionManager transactionManager;
    private final AccountRepositoryTransactionManager accountRepositoryTransactionManager;

    public AccountServiceTransactionManager(PlatformTransactionManager transactionManager, AccountRepositoryTransactionManager accountRepositoryTransactionManager) {
        this.transactionManager = transactionManager;
        this.accountRepositoryTransactionManager = accountRepositoryTransactionManager;
    }

    public void transferMoney(String fromName, String toName, int amount) throws SQLException {
        // 트랜잭션 시작
        TransactionStatus status = transactionManager.getTransaction(new DefaultTransactionDefinition());

        try {
            // 출금
            accountRepositoryTransactionManager.withdraw(fromName, amount);
            log.info("Transaction started for: {}", fromName);

            // 입금
            accountRepositoryTransactionManager.deposit(toName, amount);

            // 트랜잭션 커밋
            transactionManager.commit(status);
            log.info("Transaction committed for: {} -> {}", fromName, toName);

        } catch (Exception e) {
            // 트랜잭션 롤백
            transactionManager.rollback(status);
            log.error("Transaction rolled back due to an error: {}", e.getMessage());
            throw e; // 예외 재발생
        }
    }

    @Transactional
    public void transferMoneyTransactional(String fromName, String toName, int amount) throws SQLException {
        // 출금
        accountRepositoryTransactionManager.withdraw(fromName, amount);
        log.info("Transaction started for: {}", fromName);

        // 입금
        accountRepositoryTransactionManager.deposit(toName, amount);
    }

    @Transactional
    public void transferMoneyTransactionalError(String fromName, String toName, int amount) throws SQLException {
        // 출금
        accountRepositoryTransactionManager.withdraw(fromName, amount);
        log.info("Transaction started for: {}", fromName);
        throw new RuntimeException("exception");
        // 입금
//        accountRepositoryTransactionManager.deposit(toName, amount);
    }

    public void transferMoneyWithDelay(String fromName, String toName, int amount) throws SQLException, InterruptedException {

        TransactionStatus status = transactionManager.getTransaction(new DefaultTransactionDefinition());

        try {
            // 출금
            accountRepositoryTransactionManager.withdraw(fromName, amount);
            log.info("Transaction started for: {}", fromName);

            // 인위적인 지연
            Thread.sleep(5000); // 5초 대기

            // 입금
            accountRepositoryTransactionManager.deposit(toName, amount);

            // 트랜잭션 커밋
            transactionManager.commit(status);
            log.info("Transaction committed for: {} -> {}", fromName, toName);

        } catch (Exception e) {
            transactionManager.rollback(status);
            log.error("Transaction rolled back due to an error: {}", e.getMessage());
            throw e;
        }
    }

    public Account findAccountByName(String name) throws SQLException {

        TransactionStatus status = transactionManager.getTransaction(new DefaultTransactionDefinition());

        try {
            // 계좌 조회
            Account account = accountRepositoryTransactionManager.findByName(name);
            transactionManager.commit(status);
            return account;
        } catch (Exception e) {
            transactionManager.rollback(status);
            log.error("Transaction rolled back due to an error: {}", e.getMessage());
            throw e;
        }
    }
}

p313 - src/test/java/spring/jdbc/service/AccountServiceTransactionManagerTest

@Slf4j
class AccountServiceTransactionManagerTest {

    private static final String URL = "jdbc:mysql://localhost:3306/test";
    private static final String USERNAME = "root";
    private static final String PASSWORD = "1234";

    private DataSource dataSource;
    private AccountRepositoryTransactionManager accountRepository;
    private AccountServiceTransactionManager accountService;

    @BeforeEach
    public void setUp() throws SQLException {
        // HikariCP 설정 및 MySQL 연결
        HikariConfig config = new HikariConfig();
        config.setJdbcUrl(URL);
        config.setUsername(USERNAME);
        config.setPassword(PASSWORD);
        dataSource = new HikariDataSource(config);

        PlatformTransactionManager transactionManager = new DataSourceTransactionManager(dataSource);

        // Repository 및 Service 인스턴스 초기화
        accountRepository = new AccountRepositoryTransactionManager(dataSource);
        accountService = new AccountServiceTransactionManager(transactionManager, accountRepository);

        // 계좌 및 유저 생성
        Connection connection = null;
        try {
            connection = dataSource.getConnection();
            connection.setAutoCommit(false); // 트랜잭션 시작
            // 계좌가 이미 있으면 삭제 후 생성
            accountRepository.deleteAccount("AccountA");
            accountRepository.deleteAccount("AccountB");
            accountRepository.createAccount("AccountA", 1000);
            accountRepository.createAccount("AccountB", 1000);
            connection.commit();
        } catch (Exception e) {
            throw e;
        }
    }

    @AfterEach
    public void tearDown() throws SQLException {
        // 테스트 후 계좌 초기화
        try (Connection connection = dataSource.getConnection()) {
            connection.setAutoCommit(false); // 트랜잭션 시작
            // 계좌 삭제
            accountRepository.deleteAccount("AccountA");
            accountRepository.deleteAccount("AccountB");
            connection.commit();
        }
    }

    @Test
    public void testConcurrentTransactionIssue() throws InterruptedException {
        // 스레드 1: 계좌 A에서 B로 송금
        Thread thread1 = new Thread(() -> {
            try {
                accountService.transferMoney("AccountA", "AccountB", 500);
            } catch (SQLException e) {
                System.out.println("Thread 1 Error: " + e.getMessage());
            }
        });

        // 스레드 2: 계좌 A에서 B로 동시에 송금 (동일한 자원 접근)
        Thread thread2 = new Thread(() -> {
            try {
                accountService.transferMoney("AccountA", "AccountB", 500);
            } catch (SQLException e) {
                System.out.println("Thread 2 Error: " + e.getMessage());
            }
        });

        // 두 스레드를 거의 동시에 시작
        thread1.start();
        thread2.start();

        // 두 스레드가 끝날 때까지 기다림
        thread1.join();
        thread2.join();

        try {
            Account accountA = accountService.findAccountByName("AccountA");
            Account accountB = accountService.findAccountByName("AccountB");
            assertEquals(0, accountA.getAmount());  // AccountA는 0이어야 함
            assertEquals(2000, accountB.getAmount());  // AccountB는 2000이어야 함
        } catch (Exception e) {
            fail("Database error: " + e.getMessage());
        }
    }

    @Test
    public void testTransactionLockIssue() throws InterruptedException {
        // 스레드 1: 계좌 A에서 B로 송금 (트랜잭션 지연)
        Thread thread1 = new Thread(() -> {
            try {
                accountService.transferMoneyWithDelay("AccountA", "AccountB", 500);
            } catch (SQLException e) {
                System.out.println("Thread 1 Error: " + e.getMessage());
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        });

        // 스레드 2: 계좌 A에서 B로 동시에 송금 (락이 걸린 상태로 접근 시도)
        Thread thread2 = new Thread(() -> {
            try {
                accountService.transferMoneyWithDelay("AccountA", "AccountB", 500);
            } catch (SQLException e) {
                System.out.println("Thread 2 Error: " + e.getMessage());
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        });

        // 두 스레드를 거의 동시에 시작
        thread1.start();
        thread2.start();

        // 두 스레드가 끝날 때까지 기다림
        thread1.join();
        thread2.join();

        // 결과 확인: AccountA 잔액 확인 (트랜잭션이 실패하면 그대로 남아있어야 함)
        try {
            Account accountA = accountService.findAccountByName("AccountA");
            Account accountB = accountService.findAccountByName("AccountB");
            log.info("accountA getAmout : {}", accountA.getAmount());
            log.info("accountB getAmount : {}", accountB.getAmount());
            // 두 트랜잭션이 충돌했기 때문에 AccountA의 잔액이 0이 아닐 수도 있음
            assertTrue(accountA.getAmount() >= 0 && accountA.getAmount() <= 1000);
            assertTrue(accountB.getAmount() >= 1000 && accountB.getAmount() <= 2000);
        } catch (Exception e) {
            fail("Database error: " + e.getMessage());
        }
    }
}

p318, 320, 321 ~ 324 - src/test/java/spring/jdbc/service/AccountServiceTransactionTest

@Slf4j
@SpringBootTest
public class AccountServiceTransactionTest {
    // 나중에 application.properties로 뺄 거임 환경설정
    private static final String URL = "jdbc:mysql://localhost:3306/test";
    private static final String USERNAME = "root";
    private static final String PASSWORD = "1234";

    @Autowired
    private DataSource dataSource;
    @Autowired
    private AccountRepositoryTransactionManager accountRepository;
    @Autowired
    private AccountServiceTransactionManager accountService;
    @TestConfiguration
    static class TestConfig {
        @Bean
        public DataSource dataSource() {
            // HikariCP 설정 및 MySQL 연결
            HikariConfig config = new HikariConfig();
            config.setJdbcUrl(URL);
            config.setUsername(USERNAME);
            config.setPassword(PASSWORD);
            return new HikariDataSource(config);
        }

        @Bean
        public PlatformTransactionManager transactionManager(DataSource dataSource) {
            return new DataSourceTransactionManager(dataSource);
        }

        @Bean
        public AccountRepositoryTransactionManager accountRepositoryTransactionManager(DataSource dataSource) {
            return new AccountRepositoryTransactionManager(dataSource);
        }

        @Bean
        public AccountServiceTransactionManager accountServiceTransactionManager(PlatformTransactionManager transactionManager,
                                                                                 AccountRepositoryTransactionManager accountRepositoryTransactionManager) {
            return new AccountServiceTransactionManager(transactionManager, accountRepositoryTransactionManager);
        }
    }

    @BeforeEach
    public void setUp() throws SQLException {
        Connection connection = null;
        try {
            connection = dataSource.getConnection();
            connection.setAutoCommit(false); // 트랜잭션 시작
            // 계좌가 이미 있으면 삭제 후 생성
            accountRepository.deleteAccount("AccountA");
            accountRepository.deleteAccount("AccountB");
            accountRepository.createAccount("AccountA", 1000);
            accountRepository.createAccount("AccountB", 1000);
            connection.commit();
        } catch (Exception e) {
            throw e;
        }
    }

    @AfterEach
    public void tearDown() throws SQLException {
        // 테스트 후 계좌 초기화
        try (Connection connection = dataSource.getConnection()) {
            connection.setAutoCommit(false); // 트랜잭션 시작
            // 계좌 삭제
            accountRepository.deleteAccount("AccountA");
            accountRepository.deleteAccount("AccountB");
            connection.commit();
        }
    }


    @Test
    public void testTransferMoneyTransactional() throws SQLException {
        // 초기 상태 확인
        Account accountA = accountRepository.findByName("AccountA");
        Account accountB = accountRepository.findByName("AccountB");
        assertEquals(1000, accountA.getAmount());
        assertEquals(1000, accountB.getAmount());

        // 계좌 A에서 B로 500원을 송금
        accountService.transferMoneyTransactional("AccountA", "AccountB", 500);

        // 송금 후 상태 확인
        accountA = accountRepository.findByName("AccountA");
        accountB = accountRepository.findByName("AccountB");
        assertEquals(500, accountA.getAmount());  // AccountA는 500원 차감되어야 함
        assertEquals(1500, accountB.getAmount()); // AccountB는 500원 증가해야 함
    }

    @Test
    public void testTransferMoneyTransactionalErrorRollback() throws SQLException {
        // 초기 상태 확인
        Account accountA = accountRepository.findByName("AccountA");
        Account accountB = accountRepository.findByName("AccountB");
        assertEquals(1000, accountA.getAmount());
        assertEquals(1000, accountB.getAmount());

        // 예외가 발생하여 트랜잭션이 롤백되는지 테스트
        Exception exception = assertThrows(RuntimeException.class, () -> {
            accountService.transferMoneyTransactionalError("AccountA", "AccountB", 500);
        });

        // 예외 메시지 확인
        assertEquals("exception", exception.getMessage());

        // 트랜잭션 롤백 후 상태 확인
        accountA = accountRepository.findByName("AccountA");
        accountB = accountRepository.findByName("AccountB");

        // 롤백으로 인해 잔액이 변경되지 않았음을 확인
        assertEquals(1000, accountA.getAmount());  // AccountA는 여전히 1000원이어야 함 (롤백됨)
        assertEquals(1000, accountB.getAmount());  // AccountB도 여전히 1000원이어야 함 (롤백됨)
    }

}

p325 - src/test/resources/application.properties

# Application Name
spring.application.name=template

# MySQL Database Configuration
spring.datasource.url=jdbc:mysql://localhost:3306/test
spring.datasource.username=root
spring.datasource.password=1234

# HikariCP Configuration
spring.datasource.hikari.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.hikari.connection-timeout=30000
spring.datasource.hikari.maximum-pool-size=10
spring.datasource.hikari.pool-name=HikariPool

logging.level.org.springframework.transaction=TRACE
logging.level.org.springframework.transaction.interceptor.TransactionInterceptor=TRACE
logging.level.org.springframework.jdbc.datasource.DataSourceTransactionManager=TRACE

logging.level.org.springframework.jdbc.core=DEBUG
logging.level.org.hibernate.SQL=DEBUG
logging.level.org.hibernate.type=TRACE

logging.level.org.mybatis.spring.SqlSessionTemplate=DEBUG
logging.level.jdbc.sqlonly=TRACE

p326, 327 - src/test/java/spring/jdbc/transaction

@Slf4j
@SpringBootTest // 메인 클래스 추가
public class TransactionTest {

    @Autowired
    private TestService testService;

    @Test
    void proxyClassTest() {
        log.info("service class = {}", testService.getClass());
        Assertions.assertThat(AopUtils.isAopProxy(testService)).isTrue();
    }

    @Test
    void execMethod() {
        testService.annoTx();
        testService.nonTx();
    }

    @TestConfiguration
    static class TestConfig {
        @Bean
        TestService testService() {
            return new TestService();
        }
    }

    @Slf4j
    static class TestService {
        @Transactional
        public void annoTx() {
            log.info("annot Tx");
            boolean isActive = TransactionSynchronizationManager.isActualTransactionActive();
            log.info("annot Tx isActive = {}", isActive);
        }

        public void nonTx() {
            log.info("non Tx");
            boolean isActive = TransactionSynchronizationManager.isActualTransactionActive();
            log.info("non Tx isActive = {}", isActive);
        }
    }
}

p328 - src/test/java/spring/jdbc/transaction/TransactionLevelTest

@Slf4j
@SpringBootTest
public class TransactionLevelTest {

    @Autowired
    private TransactionalService transactionalService;

    @Test
    void transactionPriorityTest() {
        transactionalService.classTransactionalMethod();
        transactionalService.methodTransactionalMethod();
    }

    @TestConfiguration
    static class TestConfig {
        @Bean
        public TransactionalService transactionalService() {
            return new TransactionalService();
        }
    }

    @Slf4j
    @Transactional(readOnly = true)  // 클래스 레벨 트랜잭션 설정
    static class TransactionalService {

        public void classTransactionalMethod() {
            log.info("Executing classTransactionalMethod");
            boolean isActive = TransactionSynchronizationManager.isActualTransactionActive();
            boolean isReadOnly = TransactionSynchronizationManager.isCurrentTransactionReadOnly();
            log.info("classTransactionalMethod - Transaction active: {}, readOnly: {}", isActive, isReadOnly);
        }

        @Transactional // 메서드 레벨 트랜잭션 설정 (기본 설정, 읽기 전용 아님)
        public void methodTransactionalMethod() {
            log.info("Executing methodTransactionalMethod");
            boolean isActive = TransactionSynchronizationManager.isActualTransactionActive();
            boolean isReadOnly = TransactionSynchronizationManager.isCurrentTransactionReadOnly();
            log.info("methodTransactionalMethod - Transaction active: {}, readOnly: {}", isActive, isReadOnly);
        }
    }
}

p329 - src/test/java/spring/jdbc/transaction/TransactionActiveTest

@Slf4j
@SpringBootTest
public class TransactionLevelTest {

    @Autowired
    private TransactionalService transactionalService;

    @Test
    void transactionPriorityTest() {
        transactionalService.classTransactionalMethod();
        transactionalService.methodTransactionalMethod();
    }

    @TestConfiguration
    static class TestConfig {
        @Bean
        public TransactionalService transactionalService() {
            return new TransactionalService();
        }
    }

    @Slf4j
    @Transactional(readOnly = true)  // 클래스 레벨 트랜잭션 설정
    static class TransactionalService {

        public void classTransactionalMethod() {
            log.info("Executing classTransactionalMethod");
            boolean isActive = TransactionSynchronizationManager.isActualTransactionActive();
            boolean isReadOnly = TransactionSynchronizationManager.isCurrentTransactionReadOnly();
            log.info("classTransactionalMethod - Transaction active: {}, readOnly: {}", isActive, isReadOnly);
        }

        @Transactional // 메서드 레벨 트랜잭션 설정 (기본 설정, 읽기 전용 아님)
        public void methodTransactionalMethod() {
            log.info("Executing methodTransactionalMethod");
            boolean isActive = TransactionSynchronizationManager.isActualTransactionActive();
            boolean isReadOnly = TransactionSynchronizationManager.isCurrentTransactionReadOnly();
            log.info("methodTransactionalMethod - Transaction active: {}, readOnly: {}", isActive, isReadOnly);
        }
    }
}

p330, 331 - src/test/java/spring/jdbc/transaction/TransactionNotApplied

@Slf4j
@SpringBootTest
public class TransactionNotApplied {

    @Autowired
    private TestService testService;

    @Test
    void selfInvocationTest() {
        log.info("Self-invocation Test Start");
        testService.outerMethod();
    }

    @Test
    void staticMethodTest() {
        log.info("Static Method Test Start");
        TestService.staticTransactionalMethod();
    }

    @Test
    void directInvocationTest() {
        log.info("Direct Invocation Test Start");
        testService.nonTransactionalMethod();
    }

    @TestConfiguration
    static class TestConfig {
        @Bean
        public TestService testService() {
            return new TestService();
        }
    }

    @Slf4j
    static class TestService {

        // Self-invocation example
        public void outerMethod() {
            log.info("Outer method called");
            innerTransactionalMethod();
        }

        @Transactional
        public void innerTransactionalMethod() {
            log.info("Inner transactional method called");
            boolean isActive = TransactionSynchronizationManager.isActualTransactionActive();
            log.info("Inner method transaction active: {}", isActive);
        }

        // Static method example
        @Transactional
        public static void staticTransactionalMethod() {
            log.info("Static transactional method called");
            boolean isActive = TransactionSynchronizationManager.isActualTransactionActive();
            log.info("Static method transaction active: {}", isActive);
        }

        // Direct invocation example
        public void nonTransactionalMethod() {
            log.info("Non-transactional method called");
            nonAnnotatedMethod();
        }

        @Transactional
        public void nonAnnotatedMethod() {
            log.info("Non-annotated transactional method called");
            boolean isActive = TransactionSynchronizationManager.isActualTransactionActive();
            log.info("Non-annotated method transaction active: {}", isActive);
        }
    }
}

p332 - src/test/java/spring/jdbc/transaction/PostConstructTransactionTest

@Slf4j
@SpringBootTest
public class PostConstructTransactionTest {

    @Autowired
    private TestClassActive ts;

    @Test
    void contextLoads() {
        // 테스트가 정상적으로 ApplicationReadyEvent까지 실행되는지 확인
        ts.manualInvoke(); // 수동으로 메서드 호출하여 트랜잭션 상태 확인
    }

    @Slf4j
    @Service
    static class TestClassActive {

        @PostConstruct
        @Transactional
        public void initPostConstruct() {
            boolean isActive = TransactionSynchronizationManager.isActualTransactionActive();
            log.info("TestClassActive init @PostConstruct tx active={}", isActive);
        }

        @EventListener(ApplicationReadyEvent.class)
        @Transactional
        public void initApplicationReadyEvent() {
            boolean isActive = TransactionSynchronizationManager.isActualTransactionActive();
            log.info("TestClassActive init ApplicationReadyEvent tx active={}", isActive);
        }

        public void manualInvoke() {
            log.info("Manual method invoked to check transaction state post-startup");
            boolean isActive = TransactionSynchronizationManager.isActualTransactionActive();
            log.info("Manual invocation - Transaction active: {}", isActive);
        }
    }

    @TestConfiguration
    static class TestConfig {

        @Bean
        public TestClassActive ts() {
            return new TestClassActive();
        }
    }
}

p336(왼쪽이미지) - src/test/java/spring/jdbc/exception/CheckedExceptionServiceTest

// 커스텀 체크 예외 클래스
class CustomCheckedException extends Exception {
    public CustomCheckedException(String message) {
        super(message);
    }
}

// 체크 예외를 발생시키는 서비스 클래스
class CheckedExceptionService {

    // 커스텀 체크 예외를 발생시키는 메서드
    public void throwCustomCheckedException() throws CustomCheckedException {
        // 일부러 체크 예외를 발생시킴
        throw new CustomCheckedException("This is a custom checked exception");
    }
}

// 체크 예외를 테스트하는 클래스
public class CheckedExceptionServiceTest {



    private final CheckedExceptionService checkedExceptionService = new CheckedExceptionService();

    // 커스텀 체크 예외가 발생하는지 테스트하는 메서드
    @Test
    public void testThrowCustomCheckedException() {
        // 커스텀 체크 예외가 발생하는지 확인
        assertThrows(CustomCheckedException.class, () -> {
            checkedExceptionService.throwCustomCheckedException(); // 반드시 처리하거나 던져야 함
        });
    }

    // 커스텀 체크 예외를 처리하는 테스트
    @Test
    public void testHandleCustomCheckedException() {
        // 커스텀 체크 예외를 처리하는 테스트
        try {
            checkedExceptionService.throwCustomCheckedException(); // 예외를 던짐
        } catch (CustomCheckedException e) {
            // 예외를 처리하고, 메시지를 확인
            System.out.println("Caught custom checked exception: " + e.getMessage());
            assertEquals("This is a custom checked exception", e.getMessage());
        }
    }
}

p336(오른쪽이미지) - src/test/java/spring/jdbc/exception/UncheckedExceptionServiceTest

// 커스텀 언체크 예외 클래스
class CustomUncheckedException extends RuntimeException {
    public CustomUncheckedException(String message) {
        super(message);
    }
}

// 언체크 예외를 발생시키는 서비스 클래스
// 언체크 예외는 던지는 것 생략해도 됨 자연스럽게 상위로 넘어감
class UncheckedExceptionService {

    // 커스텀 언체크 예외를 발생시키는 메서드
    public void throwCustomUncheckedException() {
        // 일부러 언체크 예외를 발생시킴
        throw new CustomUncheckedException("This is a custom unchecked exception");
    }

    // 정상적인 동작을 하는 메서드 (예외 발생 없음)
    public void normalOperation() {
        System.out.println("Normal operation executed successfully.");
    }
}

// 언체크 예외를 테스트하는 클래스
public class UncheckedExceptionServiceTest {

    private final UncheckedExceptionService uncheckedExceptionService = new UncheckedExceptionService();

    // 커스텀 언체크 예외가 발생하는지 테스트하는 메서드
    @Test
    public void testThrowCustomUncheckedException() {
        // 커스텀 언체크 예외가 발생하는지 확인
        assertThrows(CustomUncheckedException.class, () -> {
            uncheckedExceptionService.throwCustomUncheckedException(); // 예외 발생
        });
    }

    // 커스텀 언체크 예외가 처리되었는지 테스트
    @Test
    public void testHandleCustomUncheckedException() {
        // 커스텀 언체크 예외를 처리하는 테스트
        try {
            uncheckedExceptionService.throwCustomUncheckedException(); // 예외를 던짐
        } catch (CustomUncheckedException e) {
            // 예외를 처리하고, 메시지를 확인
            System.out.println("Caught custom unchecked exception: " + e.getMessage());
            assertEquals("This is a custom unchecked exception", e.getMessage());
        }
    }

    // 정상적인 동작을 테스트하는 메서드
    @Test
    public void testNormalOperation() {
        // 예외가 발생하지 않는 정상적인 메서드 호출
        uncheckedExceptionService.normalOperation(); // 정상 동작 호출
    }
}

p338 - src/test/resources/application.properties

# Application Name
spring.application.name=template

# MySQL Database Configuration
spring.datasource.url=jdbc:mysql://localhost:3306/test
spring.datasource.username=root
spring.datasource.password=1234

# HikariCP Configuration
spring.datasource.hikari.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.hikari.connection-timeout=30000
spring.datasource.hikari.maximum-pool-size=10
spring.datasource.hikari.pool-name=HikariPool

logging.level.org.springframework.transaction=TRACE
logging.level.org.springframework.transaction.interceptor.TransactionInterceptor=TRACE
logging.level.org.springframework.jdbc.datasource.DataSourceTransactionManager=TRACE

logging.level.org.springframework.jdbc.core=DEBUG
logging.level.org.hibernate.SQL=DEBUG
logging.level.org.hibernate.type=TRACE

logging.level.org.mybatis.spring.SqlSessionTemplate=DEBUG
logging.level.jdbc.sqlonly=TRACE

p339 - src/test/java/spring/jdbc/transaction/TransactionExceptionTest

@Slf4j
@SpringBootTest
public class TransactionExceptionTest {

    @Autowired
    private TransactionalService transactionalService;

    @TestConfiguration
    static class TestConfig {

        @Bean
        TransactionalService transactionalService() {
            return new TransactionalService();
        }
    }

    @Test
    void uncheckedExceptionTest() {
        try {
            transactionalService.methodWithUncheckedException();
        } catch (RuntimeException e) {
            log.info("Caught unchecked exception: {}", e.getMessage());
        }
    }

    @Test
    void checkedExceptionTest() {
        try {
            transactionalService.methodWithCheckedException();
        } catch (Exception e) {
            log.info("Caught checked exception: {}", e.getMessage());
        }
    }

    @Test
    void checkedExceptionWithRollbackTest() {
        try {
            transactionalService.methodWithCheckedExceptionRollback();
        } catch (Exception e) {
            log.info("Caught checked exception (with rollback): {}", e.getMessage());
        }
    }

    @Slf4j
    static class TransactionalService {
        @Transactional  // 런타임 예외 발생 시 롤백
        public void methodWithUncheckedException() {
            log.info("Starting transaction for unchecked exception");
            registerTransactionStatusLog();
            throw new IllegalArgumentException("Unchecked exception occurred");
        }

        @Transactional  // 체크 예외 발생 시 롤백 없이 커밋됨
        public void methodWithCheckedException() throws Exception {
            log.info("Starting transaction for checked exception");
            registerTransactionStatusLog();
            throw new Exception("Checked exception occurred");
        }

        @Transactional(rollbackFor = Exception.class)  // 체크 예외 발생 시 롤백 수행
        public void methodWithCheckedExceptionRollback() throws Exception {
            log.info("Starting transaction for checked exception with rollback");
            registerTransactionStatusLog();
            throw new Exception("Checked exception occurred (rollback enabled)");
        }

        private void registerTransactionStatusLog() {
            // 트랜잭션 종료 후 커밋 또는 롤백 여부 확인
            TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {
                @Override
                public void afterCompletion(int status) {
                    if (status == STATUS_COMMITTED) {
                        log.info("Transaction was committed.");
                    } else if (status == STATUS_ROLLED_BACK) {
                        log.info("Transaction was rolled back.");
                    }
                }
            });
        }
    }
}

p347 ~ 350 - src/test/java/spring/jdbc/transaction/NestedTransactionTest

@Slf4j
@SpringBootTest
public class NestedTransactionTest {

    @Autowired
    private OuterService outerService;

    @TestConfiguration
    static class TestConfig {

        @Autowired
        private DataSource dataSource;  // DataSource를 자동 주입

        @Bean
        OuterService outerService() {
            return new OuterService(innerService());
        }

        @Bean
        InnerService innerService() {
            return new InnerService(transactionManager());
        }

        @Bean
        PlatformTransactionManager transactionManager() {
            return new DataSourceTransactionManager(dataSource);  // DataSource 주입
        }
    }
    @Test
    @DisplayName("REQUIRES_NEW 트랜잭션 롤백, REQUIRED 트랜잭션 커밋, 외부 트랜잭션 커밋")
    void testInnerRollbackRequiredCommitOuterCommit() {
        outerService.outerMethodWithMixedInnerTransactionsCommit();
    }

    @Slf4j
    static class OuterService {
        private final InnerService innerService;

        public OuterService(InnerService innerService) {
            this.innerService = innerService;
        }

        @Transactional
        public void outerMethodWithMixedInnerTransactionsCommit() {
            log.info("외부 트랜잭션 시작: 혼합된 내부 트랜잭션 포함");

            // 첫 번째 내부 트랜잭션 - REQUIRES_NEW (롤백 유도)
            try {
                innerService.innerMethodWithRequiresNewRollback();
            } catch (RuntimeException e) {
                log.info("내부 REQUIRES_NEW 트랜잭션 롤백 발생으로 인한 예외: {}", e.getMessage());
            }

            // 두 번째 내부 트랜잭션 - REQUIRED (커밋)
            innerService.innerMethodWithRequired();

            log.info("외부 트랜잭션 완료 후 상태 확인");
        }
    }

    @Slf4j
    static class InnerService {
        private final PlatformTransactionManager transactionManager;

        public InnerService(PlatformTransactionManager transactionManager) {
            this.transactionManager = transactionManager;
        }

        // 독립적인 롤백을 수행하는 REQUIRES_NEW 트랜잭션 메서드
        @Transactional(propagation = Propagation.REQUIRES_NEW)
        public void innerMethodWithRequiresNewRollback() {
            log.info("REQUIRES_NEW로 설정된 내부 트랜잭션 (롤백) 실행 중.");

            // 트랜잭션 완료 후 상태를 확인하기 위한 Synchronization 등록
            TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {
                @Override
                public void afterCompletion(int status) {
                    if (status == TransactionSynchronization.STATUS_COMMITTED) {
                        log.info("REQUIRES_NEW 트랜잭션이 커밋되었습니다.");
                    } else if (status == TransactionSynchronization.STATUS_ROLLED_BACK) {
                        log.info("REQUIRES_NEW 트랜잭션이 롤백되었습니다.");
                    }
                }
            });

            // 강제 예외 발생으로 트랜잭션 롤백 유도
            throw new RuntimeException("강제 예외 발생으로 REQUIRES_NEW 트랜잭션 롤백 유도");
        }

        // 외부 트랜잭션에 종속적으로 작동하며 커밋됨
        @Transactional(propagation = Propagation.REQUIRED)
        public void innerMethodWithRequired() {
            log.info("REQUIRED로 설정된 내부 트랜잭션 (외부와 함께 커밋) 실행 중.");
        }
    }
}