val proxyFactory = ProxyFactory()
proxyFactory.addInterface(TestService::class)
proxyFactory.addAdvice(advice)
proxyFactory.addAdvisor(advisor)

@Transactional
public void processOrder(Order order) {
    orderRepository.save(order);
    paymentService.processPayment(order);
}

val connection = dataSource.connection
connection.autoCommit = false // Transactional 어노테이션을 사용한 경우 Auto-commit 비활성화 

try {
    // SQL 실행
    connection.commit()
} catch (e: Exception) {
    connection.rollback()
    throw e
} finally {
    connection.close()
}

@Transactional
fun methodA() {
    // 물리 트랜잭션 시작
    repository.save(entityA) 
    methodB()
    // 커밋 또는 롤백
}

@Transactional(propagation = Propagation.REQUIRED)
fun methodB() {
    // 같은 물리 트랜잭션 사용
    repository.save(entityB)
}

@Transactional
fun parentMethod() {
    orderService.placeOrder() // 기존 트랜잭션
    paymentService.processPayment() // 새 트랜잭션 시작
}

@Transactional(propagation = Propagation.REQUIRED_NEW)
class PaymentService {
    fun processPayment() {
        // Do Something
    }
}

@Transactional
fun parentMethod() {
    try {
        childMethod()
    } catch (e: Exception) {
        // childMethod 롤백, parentMethod는 유지
    }
}

@Transactional(propagation = Propagation.NESTED)
fun childMethod() {
    // Savepoint 생성됨
    repository.save(entity)
    throw RuntimeException("Rollback only child")
}

@Transactional(isolation = Isolation.DEFAULT)
fun defaultIsolationExample() {
    val account = accountRepository.findById(1L).get()
    account.balance -= 100
    accountRepository.save(account)
}

@Transactional(isolation = Isolation.READ_UNCOMMITTED)
fun readUncommittedExample() {
    val balance = accountRepository.findBalanceById(1L)
    println("Balance: $balance")
}

-- Transaction A
BEGIN;
UPDATE accounts SET balance = 1000 WHERE id = 1;

-- Transaction B
SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
SELECT balance FROM accounts WHERE id = 1; 
-- 💡 1000이 보임 (Dirty Read)

-- Transaction A
ROLLBACK;

@Transactional(isolation = Isolation.READ_COMMITTED)
fun readCommittedExample() {
    val balance = accountRepository.findBalanceById(1L)
    println("Balance: $balance")
}

-- Transaction A
BEGIN;
SELECT balance FROM accounts WHERE id = 1; -- 💡 500

-- Transaction B
BEGIN;
UPDATE accounts SET balance = 700 WHERE id = 1;
COMMIT;

-- Transaction A
SELECT balance FROM accounts WHERE id = 1; -- 💡 700 (값이 변경됨, Non-repeatable Read)
COMMIT;

@Transactional(isolation = Isolation.REPEATABLE_READ)
fun repeatableReadExample() {
    val balance1 = accountRepository.findBalanceById(1L)
    println("First Read: $balance1")

    // 다른 트랜잭션이 값을 변경해도 보이지 않음
    val balance2 = accountRepository.findBalanceById(1L)
    println("Second Read: $balance2")
}

-- Transaction A
BEGIN;
SELECT balance FROM accounts WHERE id = 1; -- 💡 500

-- Transaction B
BEGIN;
UPDATE accounts SET balance = 800 WHERE id = 1;
COMMIT;

-- Transaction A
SELECT balance FROM accounts WHERE id = 1; -- 💡 500 (변경된 값이 보이지 않음)
COMMIT;

@Transactional(isolation = Isolation.SERIALIZABLE)
fun serializableExample() {
    val accounts = accountRepository.findAll()
    println("Accounts: $accounts")
}

-- Transaction A
BEGIN;
SELECT * FROM accounts WHERE balance > 500;

-- Transaction B
BEGIN;
INSERT INTO accounts (id, balance) VALUES (10, 600); -- 🚫 Blocked!

import org.springframework.stereotype.Service
import org.springframework.transaction.annotation.Transactional
import java.io.IOException
import java.sql.SQLException

@Service
class PaymentService(private val paymentRepository: PaymentRepository) {

    @Transactional(rollbackFor = [IOException::class, SQLException::class])
    fun processMultipleExceptions(payment: Payment) {
        paymentRepository.save(payment)
        
        if (payment.amount > 1000) {
            throw IOException("Amount exceeded limit")
        } else {
            throw SQLException("Database error occurred")
        }
    }
}

import org.springframework.stereotype.Service
import org.springframework.transaction.annotation.Transactional
import java.io.IOException

@Service
class PaymentService(private val paymentRepository: PaymentRepository) {

    @Transactional(noRollbackFor = [IOException::class])
    fun processWithNoRollback(payment: Payment) {
        paymentRepository.save(payment)
        throw IOException("Checked Exception 발생") // 💡 롤백되지 않음
    }
}

@Transactional(readOnly = true)
fun findUserById(id: Long): User {
    return userRepository.findById(id).orElseThrow()
}

import org.springframework.stereotype.Service
import org.springframework.transaction.annotation.Transactional

@Service
class UserService(private val userRepository: UserRepository) {

    @Transactional(readOnly = true)
    fun updateUserEmail(userId: Long, newEmail: String) {
        val user = userRepository.findById(userId).orElseThrow()
        user.email = newEmail
        userRepository.save(user) // 💡 예외 발생 가능성
    }
}

org.springframework.transaction.TransactionSystemException:
Could not commit JPA transaction; nested exception is javax.persistence.TransactionRequiredException

import org.springframework.data.jpa.repository.Query
import org.springframework.data.repository.CrudRepository
import org.springframework.transaction.annotation.Transactional

interface UserRepository : CrudRepository<User, Long> {

    @Transactional(readOnly = true)
    @Query("SELECT u FROM User u WHERE u.email = :email")
    fun findByEmail(email: String): User?
}

import io.kotest.core.spec.style.DescribeSpec
import io.kotest.matchers.shouldBe
import io.kotest.assertions.throwables.shouldThrow
import io.mockk.*
import jakarta.transaction.Transactional
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.boot.test.context.SpringBootTest
import org.springframework.boot.test.mock.mockito.MockBean

@SpringBootTest
@Transactional
class OrderServiceTest @Autowired constructor(
    private val orderRepository: OrderRepository
) : DescribeSpec({

    // OrderService를 Spy로 생성 (실제 메서드는 실행하되 일부는 Mock)
    val orderService = spyk(OrderService(orderRepository))

    describe("OrderService - 트랜잭션 롤백 테스트") {

        context("Order 생성 시 예외가 발생하면") {

            val order = Order(description = "Test Order")
            val initialCount = orderRepository.count()

            // Mocking: save() 호출 시 예외 발생하도록 설정
            every { orderRepository.save(any()) } throws RuntimeException("DB Error")

            it("트랜잭션이 롤백되어 개수가 증가하지 않는다") {
                shouldThrow<RuntimeException> {
                    orderService.createOrder(order)
                }

                val finalCount = orderRepository.count()
                finalCount shouldBe initialCount // 롤백되었으므로 동일해야 함
            }

            it("save() 메서드는 한 번만 호출된다") {
                verify(exactly = 1) { orderRepository.save(any()) }
            }

            afterEach {
                // MockK 상태 초기화
                clearMocks(orderRepository)
            }
        }
    }
})

@Service
class OrderService(
    private val orderRepository: OrderRepository,
    private val logService: LogService
) {

    @Transactional
    fun placeOrderWithLog(order: Order) {
        orderRepository.save(order)
        
        // Propagation.REQUIRES_NEW로 별도의 트랜잭션에서 처리됨
        logService.saveLog("Order ${order.description} created")
    }
}

@Service
class LogService(private val logRepository: LogRepository) {

    @Transactional(propagation = Propagation.REQUIRES_NEW)
    fun saveLog(message: String) {
        val log = OrderLog(message = message)
        logRepository.save(log)
    }
}

import io.kotest.core.spec.style.DescribeSpec
import io.kotest.matchers.shouldBe
import io.mockk.*
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest
import org.springframework.test.context.TestPropertySource

@DataJpaTest
@TestPropertySource(locations = ["classpath:application-test.properties"])
class OrderServiceLogTest @Autowired constructor(
    private val orderRepository: OrderRepository,
    private val logRepository: LogRepository
) : DescribeSpec({

    // MockK를 이용하여 LogService를 Spy로 생성
    val logService = spyk(LogService(logRepository))
    val orderService = OrderService(orderRepository, logService)

    describe("Propagation.REQUIRES_NEW 테스트") {

        context("메인 트랜잭션이 롤백되더라도 REQUIRES_NEW 로그는 DB에 남는다") {

            it("메인 트랜잭션은 정상 처리되지만 특정 조건에서 에러 로그만 남는다") {
                // Given
                val initialLogCount = logRepository.count()
                
                // Spy 설정: 특정 조건일 때만 예외처럼 동작하도록 설정
                every { logService.saveLog(match { it.contains("fail") }) } answers {
                    println("💡 Mocked Failure Log: $it")
                    val log = OrderLog(message = "Failed to process: $it")
                    logRepository.save(log)
                }

                // When
                orderService.placeOrderWithLog(Order(description = "fail-order"))

                // Then
                val finalLogCount = logRepository.count()
                finalLogCount shouldBe initialLogCount + 1

                // Verify: saveLog가 한 번만 호출되었는지 검증
                verify(exactly = 1) { logService.saveLog("Order fail-order created") }
            }

            afterEach {
                // MockK 초기화
                clearMocks(logService)
            }
        }
    }
})

spring:
  datasource:
    master:
      url: jdbc:mysql://localhost:3306/master_db
      username: root
      password: password
      driver-class-name: com.mysql.cj.jdbc.Driver

    replica:
      url: jdbc:mysql://localhost:3306/replica_db
      username: root
      password: password
      driver-class-name: com.mysql.cj.jdbc.Driver

import org.springframework.beans.factory.annotation.Qualifier
import org.springframework.boot.jdbc.DataSourceBuilder
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration
import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource
import javax.sql.DataSource

enum class DataSourceType {
    MASTER, REPLICA
}

object DataSourceContextHolder {
    private val contextHolder = ThreadLocal<DataSourceType>()

    fun set(dataSourceType: DataSourceType) {
        contextHolder.set(dataSourceType)
    }

    fun get(): DataSourceType {
        return contextHolder.get() ?: DataSourceType.MASTER
    }

    fun clear() {
        contextHolder.remove()
    }
}

@Configuration
class DataSourceConfig {

    @Bean
    @Qualifier("masterDataSource")
    fun masterDataSource(): DataSource {
        return DataSourceBuilder.create()
            .url("jdbc:mysql://localhost:3306/master_db")
            .username("root")
            .password("password")
            .driverClassName("com.mysql.cj.jdbc.Driver")
            .build()
    }

    @Bean
    @Qualifier("replicaDataSource")
    fun replicaDataSource(): DataSource {
        return DataSourceBuilder.create()
            .url("jdbc:mysql://localhost:3306/replica_db")
            .username("root")
            .password("password")
            .driverClassName("com.mysql.cj.jdbc.Driver")
            .build()
    }

    @Bean
    fun routingDataSource(
        @Qualifier("masterDataSource") masterDataSource: DataSource,
        @Qualifier("replicaDataSource") replicaDataSource: DataSource
    ): DataSource {
        val targetDataSources: MutableMap<Any, Any> = HashMap()
        targetDataSources[DataSourceType.MASTER] = masterDataSource
        targetDataSources[DataSourceType.REPLICA] = replicaDataSource

        val routingDataSource = object : AbstractRoutingDataSource() {
            override fun determineCurrentLookupKey(): Any {
                return DataSourceContextHolder.get()
            }
        }
        routingDataSource.setTargetDataSources(targetDataSources)
        routingDataSource.setDefaultTargetDataSource(masterDataSource)
        return routingDataSource
    }
}

import org.aspectj.lang.annotation.Aspect
import org.aspectj.lang.annotation.Before
import org.springframework.stereotype.Component
import org.springframework.transaction.annotation.Transactional

@Aspect
@Component
class DataSourceRoutingAspect {

    @Before("@annotation(transactional) && execution(* com.example..*(..))")
    fun setDataSource(transactional: Transactional) {
        if (transactional.readOnly) {
            DataSourceContextHolder.set(DataSourceType.REPLICA)
        } else {
            DataSourceContextHolder.set(DataSourceType.MASTER)
        }
    }
}

import org.springframework.stereotype.Service
import org.springframework.transaction.annotation.Transactional

@Service
class UserService(private val userRepository: UserRepository) {

    private log = getLogger()

    @Transactional(readOnly = true)
    fun getUser(email: String): User {
        // 💡 Replica DB에서 조회
        log.info("🔍 Read from Replica")
        return userRepository.findByEmail(email) ?: throw RuntimeException("User not found")
    }

    @Transactional
    fun createUser(user: User): User {
        // 💡 Master DB에 저장
        log.info("📝 Write to Master")
        return userRepository.save(user)
    }
}