스프링 트랜잭션 전파

Spring

스프링 트랜잭션 전파 - 커밋, 롤백

경딩 2026. 1. 17. 16:47

스프링 트랜잭션 전파 1 - 커밋, 롤백

트랜잭션이 둘 이상 있을 때 어떻게 동작하는지 자세히 알아보고, 스프링이 제공하는 트랜잭션 전파(propagation) 라는 개념도 알아보자.

트랜잭션 전파를 이해하는 과정에서 스프링 트랜잭션의 동작원리도 더 깊이있게 이해할 수 있다.

트랜잭션 코드를 기본 원리를 알아보자

간단한 스프링 트랜잭션 예제 코드

커밋

package study.springtx.propagation;

import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.context.TestConfiguration;
import org.springframework.context.annotation.Bean;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.interceptor.DefaultTransactionAttribute;

import javax.sql.DataSource;

@Slf4j
@SpringBootTest
public class BasicTxTest {

    @Autowired
    PlatformTransactionManager transactionManager;

    @TestConfiguration
    static class Config {
        // 수동으로 트랜잭션 매니저 설정
        // 스프링부트도 자동으로 DataSourceTransactionManager 를 등록해주지만
        // 트랜잭션 매니저가 이 빈이다 라는 걸 명확히 보기 위함
        // 학습 목적상 어떤 구현체를 쓰는지 눈으로 확인하기 좋음
        @Bean
        public PlatformTransactionManager transactionManager(DataSource dataSource) {
            return new DataSourceTransactionManager(dataSource);
        }
    }

    @Test
    void commit() {
        log.info("트랜잭션 시작");

        // 트랜잭션 시작
        // getTransaction():
        // 현재 스레드에 트랜잭션이 없으면 새로 생성
        // - Connection을 가져오고 autoCommit=false 설정
        TransactionStatus status = transactionManager.getTransaction(new DefaultTransactionAttribute());

        log.info("트랜잭션 커밋 시작");
        // 여기는 실제로는
        // 같은 스레드에서  JDBC Connection이 트랜잭션에 묶여 있음
        // 이후 실행되는 쿼리들은 모두 이 트랜잭션 안에서 실행됨

        // 트랜잭션 커밋
        // commit()
        // - Connection.commit() 호출
        // - autoCommit=true로 복구
        // 트랜잭션 리소스 정리
        transactionManager.commit(status);
        log.info("트랜잭션 커밋 완료");
    }
}

2026-01-15T22:44:01.451+09:00  INFO 1314 --- [springtx] [    Test worker] study.springtx.propagation.BasicTxTest   : Started BasicTxTest in 1.189 seconds (process running for 1.681)
2026-01-15T22:44:01.668+09:00  INFO 1314 --- [springtx] [    Test worker] study.springtx.propagation.BasicTxTest   : 트랜잭션 시작
2026-01-15T22:44:01.669+09:00 DEBUG 1314 --- [springtx] [    Test worker] o.s.j.d.DataSourceTransactionManager     : Creating new transaction with name [null]: PROPAGATION_REQUIRED,ISOLATION_DEFAULT
2026-01-15T22:44:01.669+09:00 DEBUG 1314 --- [springtx] [    Test worker] o.s.j.d.DataSourceTransactionManager     : Acquired Connection [HikariProxyConnection@352959830 wrapping conn0: url=jdbc:h2:mem:e5eb71a3-bfda-49cc-9120-8e117be6b110 user=SA] for JDBC transaction
2026-01-15T22:44:01.671+09:00 DEBUG 1314 --- [springtx] [    Test worker] o.s.j.d.DataSourceTransactionManager     : Switching JDBC Connection [HikariProxyConnection@352959830 wrapping conn0: url=jdbc:h2:mem:e5eb71a3-bfda-49cc-9120-8e117be6b110 user=SA] to manual commit
2026-01-15T22:44:01.671+09:00  INFO 1314 --- [springtx] [    Test worker] study.springtx.propagation.BasicTxTest   : 트랜잭션 커밋 시작
2026-01-15T22:44:01.671+09:00 DEBUG 1314 --- [springtx] [    Test worker] o.s.j.d.DataSourceTransactionManager     : Initiating transaction commit
2026-01-15T22:44:01.671+09:00 DEBUG 1314 --- [springtx] [    Test worker] o.s.j.d.DataSourceTransactionManager     : Committing JDBC transaction on Connection [HikariProxyConnection@352959830 wrapping conn0: url=jdbc:h2:mem:e5eb71a3-bfda-49cc-9120-8e117be6b110 user=SA]
2026-01-15T22:44:01.671+09:00 DEBUG 1314 --- [springtx] [    Test worker] o.s.j.d.DataSourceTransactionManager     : Releasing JDBC Connection [HikariProxyConnection@352959830 wrapping conn0: url=jdbc:h2:mem:e5eb71a3-bfda-49cc-9120-8e117be6b110 user=SA] after transaction
2026-01-15T22:44:01.672+09:00  INFO 1314 --- [springtx] [    Test worker] study.springtx.propagation.BasicTxTest   : 트랜잭션 커밋 완료

commit()

transactionManager.getTransaction(new DefaultTransactionAttribute());

트랜잭션 매니저를 통해 트랜잭션을 시작(획득)한다.

transactionManager.commit(status);

트랜잭션을 커밋한다.

롤백

    @Test
    void rollback() {
        log.info("트랜잭션 시작");

        /**
         * 트랜잭션 시작
         * (commit 테스트와 동일)
         */
        TransactionStatus status = transactionManager.getTransaction(new DefaultTransactionAttribute());

        log.info("트랜잭션 롤백 시작");


        // 트랜잭션 롤백
        // rollback()
        // - Connection.rollback() 호출
        // - 트랜잭션 동안 실행된 SQL 모두 취소
        // autoCommit = true 로 복
        // 트랜잭션 리소스
        transactionManager.rollback(status);
        log.info("트랜잭션 완료");
    }

2026-01-15T23:02:11.424+09:00  INFO 1447 --- [springtx] [    Test worker] study.springtx.propagation.BasicTxTest   : Started BasicTxTest in 0.965 seconds (process running for 1.36)
2026-01-15T23:02:11.657+09:00  INFO 1447 --- [springtx] [    Test worker] study.springtx.propagation.BasicTxTest   : 트랜잭션 시작
2026-01-15T23:02:11.658+09:00 DEBUG 1447 --- [springtx] [    Test worker] o.s.j.d.DataSourceTransactionManager     : Creating new transaction with name [null]: PROPAGATION_REQUIRED,ISOLATION_DEFAULT
2026-01-15T23:02:11.659+09:00 DEBUG 1447 --- [springtx] [    Test worker] o.s.j.d.DataSourceTransactionManager     : Acquired Connection [HikariProxyConnection@717229513 wrapping conn0: url=jdbc:h2:mem:6201fbbe-5df6-4f88-beb9-c1e8112b1537 user=SA] for JDBC transaction
2026-01-15T23:02:11.660+09:00 DEBUG 1447 --- [springtx] [    Test worker] o.s.j.d.DataSourceTransactionManager     : Switching JDBC Connection [HikariProxyConnection@717229513 wrapping conn0: url=jdbc:h2:mem:6201fbbe-5df6-4f88-beb9-c1e8112b1537 user=SA] to manual commit
2026-01-15T23:02:11.661+09:00  INFO 1447 --- [springtx] [    Test worker] study.springtx.propagation.BasicTxTest   : 트랜잭션 롤백 시작
2026-01-15T23:02:11.661+09:00 DEBUG 1447 --- [springtx] [    Test worker] o.s.j.d.DataSourceTransactionManager     : Initiating transaction rollback
2026-01-15T23:02:11.661+09:00 DEBUG 1447 --- [springtx] [    Test worker] o.s.j.d.DataSourceTransactionManager     : Rolling back JDBC transaction on Connection [HikariProxyConnection@717229513 wrapping conn0: url=jdbc:h2:mem:6201fbbe-5df6-4f88-beb9-c1e8112b1537 user=SA]
2026-01-15T23:02:11.661+09:00 DEBUG 1447 --- [springtx] [    Test worker] o.s.j.d.DataSourceTransactionManager     : Releasing JDBC Connection [HikariProxyConnection@717229513 wrapping conn0: url=jdbc:h2:mem:6201fbbe-5df6-4f88-beb9-c1e8112b1537 user=SA] after transaction
2026-01-15T23:02:11.662+09:00  INFO 1447 --- [springtx] [    Test worker] study.springtx.propagation.BasicTxTest   : 트랜잭션   완료

transactionManager.rollback(status);

트랜잭션을 롤백한다.

getTransaction()
   ↓
Connection(autoCommit=false)
   ↓
[ SQL 실행 ]
   ↓
commit()   → DB 반영
rollback() → 전부 취소

스프링 트랜잭션 전파 2- 트랜잭션 두 번 사용

트랜잭션이 각각 따로 사용되는 경우를 확인해보자.

예제: 트랜잭션 1이 완전히 끝난 후 트랜잭션 2 실행

    @Test
    void double_commit() {
        log.info("트랜잭션 1 시작");
        TransactionStatus tx1 = transactionManager.getTransaction(new DefaultTransactionAttribute());
        log.info("트랜잭션1 커밋 시작");

        transactionManager.commit(tx1);
        log.info("트랜잭션1 커밋");

        log.info("트랜잭션 2 시작");
        TransactionStatus tx2 = transactionManager.getTransaction(new DefaultTransactionAttribute());
        log.info("트랜잭션2 커밋 시작");

        transactionManager.commit(tx2);
        log.info("트랜잭션2 커밋");
    }

2026-01-15T23:17:09.931+09:00  INFO 1560 --- [springtx] [    Test worker] study.springtx.propagation.BasicTxTest   : Started BasicTxTest in 0.964 seconds (process running for 1.342)
2026-01-15T23:17:10.139+09:00  INFO 1560 --- [springtx] [    Test worker] study.springtx.propagation.BasicTxTest   : 트랜잭션 1 시작
2026-01-15T23:17:10.140+09:00 DEBUG 1560 --- [springtx] [    Test worker] o.s.j.d.DataSourceTransactionManager     : Creating new transaction with name [null]: PROPAGATION_REQUIRED,ISOLATION_DEFAULT
2026-01-15T23:17:10.140+09:00 DEBUG 1560 --- [springtx] [    Test worker] o.s.j.d.DataSourceTransactionManager     : Acquired Connection [HikariProxyConnection@59966374 wrapping conn0: url=jdbc:h2:mem:d9ce44f4-e7c2-498e-977c-8ca4262c94f1 user=SA] for JDBC transaction
2026-01-15T23:17:10.141+09:00 DEBUG 1560 --- [springtx] [    Test worker] o.s.j.d.DataSourceTransactionManager     : Switching JDBC Connection [HikariProxyConnection@59966374 wrapping conn0: url=jdbc:h2:mem:d9ce44f4-e7c2-498e-977c-8ca4262c94f1 user=SA] to manual commit
2026-01-15T23:17:10.141+09:00  INFO 1560 --- [springtx] [    Test worker] study.springtx.propagation.BasicTxTest   : 트랜잭션1 커밋 시작
2026-01-15T23:17:10.141+09:00 DEBUG 1560 --- [springtx] [    Test worker] o.s.j.d.DataSourceTransactionManager     : Initiating transaction commit
2026-01-15T23:17:10.142+09:00 DEBUG 1560 --- [springtx] [    Test worker] o.s.j.d.DataSourceTransactionManager     : Committing JDBC transaction on Connection [HikariProxyConnection@59966374 wrapping conn0: url=jdbc:h2:mem:d9ce44f4-e7c2-498e-977c-8ca4262c94f1 user=SA]
2026-01-15T23:17:10.142+09:00 DEBUG 1560 --- [springtx] [    Test worker] o.s.j.d.DataSourceTransactionManager     : Releasing JDBC Connection [HikariProxyConnection@59966374 wrapping conn0: url=jdbc:h2:mem:d9ce44f4-e7c2-498e-977c-8ca4262c94f1 user=SA] after transaction
2026-01-15T23:17:10.142+09:00  INFO 1560 --- [springtx] [    Test worker] study.springtx.propagation.BasicTxTest   : 트랜잭션1 커밋


2026-01-15T23:17:10.142+09:00  INFO 1560 --- [springtx] [    Test worker] study.springtx.propagation.BasicTxTest   : 트랜잭션 2 시작
2026-01-15T23:17:10.142+09:00 DEBUG 1560 --- [springtx] [    Test worker] o.s.j.d.DataSourceTransactionManager     : Creating new transaction with name [null]: PROPAGATION_REQUIRED,ISOLATION_DEFAULT
2026-01-15T23:17:10.142+09:00 DEBUG 1560 --- [springtx] [    Test worker] o.s.j.d.DataSourceTransactionManager     : Acquired Connection [HikariProxyConnection@362427044 wrapping conn0: url=jdbc:h2:mem:d9ce44f4-e7c2-498e-977c-8ca4262c94f1 user=SA] for JDBC transaction
2026-01-15T23:17:10.142+09:00 DEBUG 1560 --- [springtx] [    Test worker] o.s.j.d.DataSourceTransactionManager     : Switching JDBC Connection [HikariProxyConnection@362427044 wrapping conn0: url=jdbc:h2:mem:d9ce44f4-e7c2-498e-977c-8ca4262c94f1 user=SA] to manual commit
2026-01-15T23:17:10.142+09:00  INFO 1560 --- [springtx] [    Test worker] study.springtx.propagation.BasicTxTest   : 트랜잭션2 커밋 시작
2026-01-15T23:17:10.142+09:00 DEBUG 1560 --- [springtx] [    Test worker] o.s.j.d.DataSourceTransactionManager     : Initiating transaction commit
2026-01-15T23:17:10.142+09:00 DEBUG 1560 --- [springtx] [    Test worker] o.s.j.d.DataSourceTransactionManager     : Committing JDBC transaction on Connection [HikariProxyConnection@362427044 wrapping conn0: url=jdbc:h2:mem:d9ce44f4-e7c2-498e-977c-8ca4262c94f1 user=SA]
2026-01-15T23:17:10.142+09:00 DEBUG 1560 --- [springtx] [    Test worker] o.s.j.d.DataSourceTransactionManager     : Releasing JDBC Connection [HikariProxyConnection@362427044 wrapping conn0: url=jdbc:h2:mem:d9ce44f4-e7c2-498e-977c-8ca4262c94f1 user=SA] after transaction
2026-01-15T23:17:10.142+09:00  INFO 1560 --- [springtx] [    Test worker] study.springtx.propagation.BasicTxTest   : 트랜잭션2 커밋

트랜잭션1

Acquired Connection [HikariProxyConnection@59966374 wrapping conn0: url=jdbc:h2:mem:d9ce44f4-e7c2-498e-977c-8ca4262c94f1 user=SA] for JDBC transaction
- 트랜잭션 1을 시작하고 conn0 커넥션을 획득했다.
Releasing JDBC Connection [HikariProxyConnection@59966374 wrapping conn0: url=jdbc:h2:mem:d9ce44f4-e7c2-498e-977c-8ca4262c94f1 user=SA] after transaction
- 트랜잭션 1을 커밋하고, 커넥션 풀에 conn0 커넥션을 반납했다.

트랜잭션2

Acquired Connection [HikariProxyConnection@362427044 wrapping conn0: url=jdbc:h2:mem:d9ce44f4-e7c2-498e-977c-8ca4262c94f1 user=SA] for JDBC transaction
- 트랜잭션 2을 시작하고 conn0 커넥션을 획득했다.
Releasing JDBC Connection [HikariProxyConnection@362427044 wrapping conn0: url=jdbc:h2:mem:d9ce44f4-e7c2-498e-977c-8ca4262c94f1 user=SA] after transaction
- 트랜잭션 2을 커밋하고, 커넥션 풀에 conn0 커넥션을 반납했다.

주의

로그를 보면 트랜잭션 1과 2과 conn0커넥션을 사용중이다. 이것은 중간에 커넥션 풀 때문에 그런것이다.

트랜잭션 1은 conn0 커넥션을 모두 사용하고 커넥션 풀에 반납까지 완료했다.

이후에 트랜잭션2가 conn0를 커넥션 풀에서 획득한 것이다. 따라서 둘은 완전히 다른 커넥션으로 인지하는 것이 맞다.

둘을 구분할 수 있는 방법

히카리커넥션 풀에서 커넥션을 획득하면 실제 커넥션을 그대로 반환하는 것이 아닌 내부 관리를 위해 히카리 프록시 커넥션이라는 객체를 생성해서 반환한다. 물론 내부에는 실제 커넥션이 포함되어 있다. 이 객체의 주소를 확인하면 커넥션풀에서 획득한 커넥션을 구분할 수 있다.

트랜잭션1:Acquired Connection [HikariProxyConnection@59966374 wrapping conn0:
트랜잭션2:Acquired Connection [HikariProxyConnection@362427044 wrapping conn0:

conn0를 통해 커넥션이 재사용된 것을 확인할 수 있고 객체 주소를 통해 각각 커넥션 풀에서 커넥션을 조회한것 을 알 수 있다.

트랜잭션이 각각 수행되면서 사용되는 DB 커넥션도 각각 다르다.

이 경우 트랜잭션을 각자 관리하기 때문에 전체 트랜잭션을 묶을 수 없다. 예를 들어서 트랜잭션1이 커밋하고, 트랜잭션2가 롤백하는 경우

트랜잭션 1에 저장한 데이터가 커밋되고, 트랜잭션2에서 저장한 데이터는 롤백된다.

    @Test
    void double_commit_rollback() {
        log.info("트랜잭션 1 시작");
        TransactionStatus tx1 = transactionManager.getTransaction(new DefaultTransactionAttribute());
        log.info("트랜잭션1 커밋");
        transactionManager.commit(tx1);


        log.info("트랜잭션 2 시작");
        TransactionStatus tx2 = transactionManager.getTransaction(new DefaultTransactionAttribute());
        log.info("트랜잭션2 롤백");
        transactionManager.rollback(tx2);

    }

예제에서는 트랜잭션1은 커밋하고, 트랜잭션2는 롤백한다.

전체 트랜잭션을 묶지 않고, 각각 관리했기 때문에, 트랜잭션 1에서 저장한 데이터는 커밋되고, 트랜잭션2 에서 저장한 데이터는 롤백된다.

2026-01-15T23:38:55.137+09:00  INFO 1652 --- [springtx] [    Test worker] study.springtx.propagation.BasicTxTest   : Started BasicTxTest in 0.975 seconds (process running for 1.362)
2026-01-15T23:38:55.355+09:00  INFO 1652 --- [springtx] [    Test worker] study.springtx.propagation.BasicTxTest   : 트랜잭션 1 시작
2026-01-15T23:38:55.356+09:00 DEBUG 1652 --- [springtx] [    Test worker] o.s.j.d.DataSourceTransactionManager     : Creating new transaction with name [null]: PROPAGATION_REQUIRED,ISOLATION_DEFAULT
2026-01-15T23:38:55.357+09:00 DEBUG 1652 --- [springtx] [    Test worker] o.s.j.d.DataSourceTransactionManager     : Acquired Connection [HikariProxyConnection@1755429681 wrapping conn0: url=jdbc:h2:mem:8d7e69f4-d792-413b-ad0d-db367dc1ed99 user=SA] for JDBC transaction
2026-01-15T23:38:55.358+09:00 DEBUG 1652 --- [springtx] [    Test worker] o.s.j.d.DataSourceTransactionManager     : Switching JDBC Connection [HikariProxyConnection@1755429681 wrapping conn0: url=jdbc:h2:mem:8d7e69f4-d792-413b-ad0d-db367dc1ed99 user=SA] to manual commit
2026-01-15T23:38:55.358+09:00  INFO 1652 --- [springtx] [    Test worker] study.springtx.propagation.BasicTxTest   : 트랜잭션1 커밋
2026-01-15T23:38:55.358+09:00 DEBUG 1652 --- [springtx] [    Test worker] o.s.j.d.DataSourceTransactionManager     : Initiating transaction commit
2026-01-15T23:38:55.359+09:00 DEBUG 1652 --- [springtx] [    Test worker] o.s.j.d.DataSourceTransactionManager     : Committing JDBC transaction on Connection [HikariProxyConnection@1755429681 wrapping conn0: url=jdbc:h2:mem:8d7e69f4-d792-413b-ad0d-db367dc1ed99 user=SA]
2026-01-15T23:38:55.359+09:00 DEBUG 1652 --- [springtx] [    Test worker] o.s.j.d.DataSourceTransactionManager     : Releasing JDBC Connection [HikariProxyConnection@1755429681 wrapping conn0: url=jdbc:h2:mem:8d7e69f4-d792-413b-ad0d-db367dc1ed99 user=SA] after transaction


2026-01-15T23:38:55.360+09:00  INFO 1652 --- [springtx] [    Test worker] study.springtx.propagation.BasicTxTest   : 트랜잭션 2 시작
2026-01-15T23:38:55.360+09:00 DEBUG 1652 --- [springtx] [    Test worker] o.s.j.d.DataSourceTransactionManager     : Creating new transaction with name [null]: PROPAGATION_REQUIRED,ISOLATION_DEFAULT
2026-01-15T23:38:55.360+09:00 DEBUG 1652 --- [springtx] [    Test worker] o.s.j.d.DataSourceTransactionManager     : Acquired Connection [HikariProxyConnection@117629468 wrapping conn0: url=jdbc:h2:mem:8d7e69f4-d792-413b-ad0d-db367dc1ed99 user=SA] for JDBC transaction
2026-01-15T23:38:55.360+09:00 DEBUG 1652 --- [springtx] [    Test worker] o.s.j.d.DataSourceTransactionManager     : Switching JDBC Connection [HikariProxyConnection@117629468 wrapping conn0: url=jdbc:h2:mem:8d7e69f4-d792-413b-ad0d-db367dc1ed99 user=SA] to manual commit
2026-01-15T23:38:55.360+09:00  INFO 1652 --- [springtx] [    Test worker] study.springtx.propagation.BasicTxTest   : 트랜잭션2 롤백
2026-01-15T23:38:55.360+09:00 DEBUG 1652 --- [springtx] [    Test worker] o.s.j.d.DataSourceTransactionManager     : Initiating transaction rollback
2026-01-15T23:38:55.361+09:00 DEBUG 1652 --- [springtx] [    Test worker] o.s.j.d.DataSourceTransactionManager     : Rolling back JDBC transaction on Connection [HikariProxyConnection@117629468 wrapping conn0: url=jdbc:h2:mem:8d7e69f4-d792-413b-ad0d-db367dc1ed99 user=SA]
2026-01-15T23:38:55.361+09:00 DEBUG 1652 --- [springtx] [    Test worker] o.s.j.d.DataSourceTransactionManager     : Releasing JDBC Connection [HikariProxyConnection@117629468 wrapping conn0: url=jdbc:h2:mem:8d7e69f4-d792-413b-ad0d-db367dc1ed99 user=SA] after transaction

스프링 트랜잭션 전파3- 전파 기본

트랜잭션을 각각 사용하는 것이 아니라, 트랜잭션이 이미 진행중인데, 여기에 추가로 트랜잭션을 수행하면 어떻게 될까?

기존 트랜잭션과 별도의 트랜잭션을 진행해야 할까? 아니면 기존 트랜잭션을 그대로 이어 받아서 트랜잭션을 수행해야 할까?

이런 경우 어떻게 동작할지 결정하는 것을 트랜잭션 전파(propagation)라 한다.

지금부터 설명하는 내용은 트랜잭션 전파의 기본 옵션인 REQUIRED를 기준으로 설명한다.

외부 트랜잭션이 수행중인데, 내부 트랜잭션이 추가로 수행된다.
외부 트랜잭션이라고 이름 붙인 것은 둘 중 상대적으로 밖에 있기 때문이다. 처음 시작된 트랜잭션으로 이해하면 된다.
내부 트랜잭션은 외부에 트랜잭션이 수행되고 있는 도중에 호출되기 때문에 마치 내부에 있는 것 처럼 보여서 내부 트랜잭션이라 한다.

스프링에서 이 경우 외부 트랜잭션과 내부 트랜잭션을 묶어서 하나의 트랜잭션을 만들어준다. 내부 트랜잭션이 외부 트랜잭션에 참여하는 것이다. 이것이 기본 동작이고 옵션에따라 다른 동작방식도 선택할 수 있다.

물리 트랜잭션, 논리 트랜잭션

스프링은 이해를 돕기 위해 논리 트랜잭션과 물리 트랜잭션이라는 개념을 나눈다.
논리 트랜잭션들은 하나의 물리 트랜잭션으로 묶인다.
물리 트랜잭션은 우리가 이해하는 실제 데이터베이스에 적용되는 트랜잭션을 뜻한다. 실제 커넥션을 통해서 트랜잭션을 시작 (setAutoCommit(false))하고, 실제 커넥션을 통해서 커밋, 롤백하는 단위이다.
논리 트랜잭션은 트랜잭션 매니저를 통해 트랜잭션을 사용하는 단위이다.
이러한 논리 트랜잭션 개념은 트랜잭션이 진행되는 중에 내부에 추가로 트랜잭션을 사용하는 경우에 나타난다. 단순히 트랜잭션이 하나인 경우 둘을 구분하지는않는다. (`REQUIRED` 전파 옵션을 사용하는 경우에 한함.)

왜 논리, 물리 트랜잭션을 나눠서 설명할까?

트랜잭션이 사용 중일때 또 다른 트랜잭션이 내부에 사용되면 여러가지 상황이 발생한다. 이때 논리 트랜잭션 개념을 도입하면 다음과 같은 원칙을 만들 수 있다.

원칙

모든 논리 트랜잭션이 커밋되어야 물리 트랜잭션이 커밋된다.
하나의 논리 트랜잭션이라도 롤백되면 물리 트랜잭션도 롤백된다.

즉 모든 트랜잭션 매니저를 커밋해야 물리 트랜잭션이 커밋된다. 하나의 트랜잭션 매니저라고 롤백되면 물리 트랜잭션은 롤백된다.

모든 논리 트랜잭션이 커밋되었으므로 물리 트랜잭션도 커밋된다.

외부 논리 트랜잭션이 롤백되면 물리 트랜잭션은 롤백된다.

내부 트랜잭션이 롤백되면 물리 트랜잭션도 롤백된다.

스프링 트랜잭션 전파4 -전파 예제

스프링 트랜잭션 전파 알아보기

    @Test
    void inner_commit() {
        log.info("외부 트랜잭션 시작");
        TransactionStatus outer = transactionManager.getTransaction(new DefaultTransactionAttribute());
        log.info("outer.isNewTransaction()={}", outer.isNewTransaction());

        log.info("내부 트랜잭션 시작");
        TransactionStatus inner = transactionManager.getTransaction(new DefaultTransactionAttribute());
        log.info("inner.isNewTransaction()={}", inner.isNewTransaction());
        log.info("내부 트랜잭션 커밋");
        transactionManager.commit(inner);

        log.info("외부 트랜잭션 커밋");
        transactionManager.commit(outer);

    }

외부 트랜잭션이 수행 중인데, 내부 트랜잭션을 추가로 수행했다.
외부 트랜잭션은 처음 수행된 트랜잭션이므로 신규 트랜잭션 isNewTransaction=true 가 된다.
내부 트랜잭션을 시작하는 시점에는 이미 외부 트랜잭션이 진행중인 상태이다. 이 경우 내부 트랜잭션은 외부 트랜잭션에 참여한다.
트랜잭션 참여
- 내부 트랜잭션이 외부 트랜잭션에 참여한다는 뜻은 내부 트랜잭션이 외부 트랜잭션을 그대로 이어받아서 따른다는 뜻이다.
- 다른 관점으로 보면 외부 트랜잭션의 범위가 내부 트랜잭션까지 넒어진다는 뜻이다.
- 외부에서 시작된 물리적인 트랜잭션의 범위가 내부 트랜잭션까지 내부 트랜잭션까지 넓어진다는 뜻이다.
- 즉 외부 트랜잭션과 내부 트랜잭션이 하나의 물리 트랜잭션으로 묶이는 것이다.
내부 트랜잭션은 이미 진행중인 외부 트랜잭션에 참여한다. 이 경우 신규 트랜잭션이 아니다.
- (`isNewTransaction=false` )
예제는 둘다 성공적으로 커밋했다.

이 예제에서는 외부 트랜잭션과 내부 트랜잭션이 하나의 물리 트랜잭션으로 묶인다고 설명했다.

그런데 코드를 잘 보면 커밋을 두번 호출했다. 트랜잭션을 생각해보면 하나의 커넥션에 커밋은 한번만 호출할 수 있다.

커밋이나 롤백을 하면 해당 트랜잭션은 끝나버린다.

transactionManager.commit(inner);
transactionManager.commit(outer);

스프링은 어떻게 외부, 내부 트랜잭션을 하나의 물리 트랜잭션으로 묶어서 동작하는지 로그를 통해 알아보자.

실행 결과 - inner_commit()

2026-01-17T15:35:20.351+09:00  INFO 2509 --- [springtx] [    Test worker] study.springtx.propagation.BasicTxTest   : Started BasicTxTest in 0.95 seconds (process running for 1.342)
2026-01-17T15:35:20.552+09:00  INFO 2509 --- [springtx] [    Test worker] study.springtx.propagation.BasicTxTest   : 외부 트랜잭션 시작
2026-01-17T15:35:20.553+09:00 DEBUG 2509 --- [springtx] [    Test worker] o.s.j.d.DataSourceTransactionManager     : Creating new transaction with name [null]: PROPAGATION_REQUIRED,ISOLATION_DEFAULT
2026-01-17T15:35:20.553+09:00 DEBUG 2509 --- [springtx] [    Test worker] o.s.j.d.DataSourceTransactionManager     : Acquired Connection [HikariProxyConnection@877611650 wrapping conn0: url=jdbc:h2:mem:821d6c0f-e28c-4aac-94d4-9fb05ad5d9c8 user=SA] for JDBC transaction
2026-01-17T15:35:20.554+09:00 DEBUG 2509 --- [springtx] [    Test worker] o.s.j.d.DataSourceTransactionManager     : Switching JDBC Connection [HikariProxyConnection@877611650 wrapping conn0: url=jdbc:h2:mem:821d6c0f-e28c-4aac-94d4-9fb05ad5d9c8 user=SA] to manual commit
2026-01-17T15:35:20.554+09:00  INFO 2509 --- [springtx] [    Test worker] study.springtx.propagation.BasicTxTest   : outer.isNewTransaction()=true


2026-01-17T15:35:20.554+09:00  INFO 2509 --- [springtx] [    Test worker] study.springtx.propagation.BasicTxTest   : 내부 트랜잭션 시작
2026-01-17T15:35:20.554+09:00 DEBUG 2509 --- [springtx] [    Test worker] o.s.j.d.DataSourceTransactionManager     : Participating in existing transaction
2026-01-17T15:35:20.554+09:00  INFO 2509 --- [springtx] [    Test worker] study.springtx.propagation.BasicTxTest   : inner.isNewTransaction()=false
2026-01-17T15:35:20.554+09:00  INFO 2509 --- [springtx] [    Test worker] study.springtx.propagation.BasicTxTest   : 내부 트랜잭션 커밋


2026-01-17T15:35:20.554+09:00  INFO 2509 --- [springtx] [    Test worker] study.springtx.propagation.BasicTxTest   : 외부 트랜잭션 커밋
2026-01-17T15:35:20.554+09:00 DEBUG 2509 --- [springtx] [    Test worker] o.s.j.d.DataSourceTransactionManager     : Initiating transaction commit
2026-01-17T15:35:20.555+09:00 DEBUG 2509 --- [springtx] [    Test worker] o.s.j.d.DataSourceTransactionManager     : Committing JDBC transaction on Connection [HikariProxyConnection@877611650 wrapping conn0: url=jdbc:h2:mem:821d6c0f-e28c-4aac-94d4-9fb05ad5d9c8 user=SA]
2026-01-17T15:35:20.555+09:00 DEBUG 2509 --- [springtx] [    Test worker] o.s.j.d.DataSourceTransactionManager     : Releasing JDBC Connection [HikariProxyConnection@877611650 wrapping conn0: url=jdbc:h2:mem:821d6c0f-e28c-4aac-94d4-9fb05ad5d9c8 user=SA] after transaction

내부 트랜잭션을 시작할 때 Participating in existing transaction이라는 메시지를 확인할 수 있다.
이 메시지는 내부 트랜잭션이 기존에 존재하는 외부 트랜잭션에 참여한다는 뜻이다.
실행 결과를 보면 외부 트랜잭션을 시작하거나 커밋할 때는 DB 커넥션을 통한 물리 트랜잭션을 manual commit 하고, DB 커넥션을 통해 커밋 하는 것을 확인할 수 있다.

정리하면, 외부 트랜잭션만 물리 트랜잭션을 시작하고, 커밋한다.

만약 내부 트랜잭션이 실제 물리 트랜잭션을 커밋하면 트랜잭션이 끝나버리기 때문에, 트랜잭션을 처음 시작한 외부 트랜잭션까지 이어갈 수 없다. 따라서 내부 트랜잭션은 DB 커넥션을 통한 물리 트랜잭션을 커밋하면 안된다.

스프링은 여러 트랜잭션이 함께 사용되는 경우, 처음 트랜잭션을 시작한 외부 트랜잭션이 실제 물리 트랜잭션을 관리하도록한다.

이를 통해서 트랜잭션 중복 커밋 문제를 해결한다.

트랜잭션 전파가 실제 어떻게 동작하는지 그림으로 알아보기

요청 흐름 - 외부 트랜잭션

txManager.getTransaction() 를 호출해서 외부 트랜잭션을 시작한다.
트랜잭션 매니저는 데이터 소스를 통해 커넥션을 생성한다.
생성한 커넥션은 수동 커밋모드(setAutoCommit(false)) 로 설정한다 - 물리 트랜잭션 시작
트랜잭션 매니저는 트랜잭션 동기화 매니저에 커넥션을 보관한다.
트랜잭션 매니저는 트랜잭션을 생성한 결과를 TransactionStatus 에 담아서 반환하는데, 여기에 신규 트랜잭션 여부가 담겨있다. isNewTransaction를 통해 신규 트랜잭션 여부를 확인할 수 있다. 트랜잭션을 처음 시작했으므로 신규 트랜잭션이다. (true)
로직 1 이 사용되고 , 커넥션이 필요한 경우 트랜잭션 동기화 매니저를 통해 트랜잭션이 적용된 커넥션을 획득해서 사용한다.

요청 흐름 - 내부 트랜잭션

txManager.getTransaction() 를 호출해서 내부 트랜잭션을 시작한다.
트랜잭션 매니저는 트랜잭션 동기화 매니저를 통해서 기존 트랜잭션이 존재하는지 확인한다.
기존 트랜잭션이 존재하므로 기존 트랜잭션에 참여한다. 기존 트랜잭션에 참여한다는 뜻은 사실 아무것도 하지 않는다는 뜻이다.
이미 기존 트랜잭션인 외부 트랜잭션에서 물리 트랜잭션을 시작했다. 그리고 물리 트랜잭션이 시작된 커넥션을 트랜잭션 동기화 매니저에 담아두었다.
1. 따라서 이미 물리 트랜잭션이 진행 중 이므로 그냥 두면 로직이 기존에 시작된 트랜잭션을 자연스럽게 사용하게 된다.
2. 이후 로직은 자연스럽게 트랜잭션 동기화 매니저에 보관된 기존 커넥션을 사용하게 된다.
3. 트랜잭션 매니저는 트랜잭션을 생성한 결과를 TransactionStatus 에 담아서 반환하는데, 여기에 신규 트랜잭션 여부가 담겨있다. isNewTransaction를 통해 신규 트랜잭션 여부를 확인할 수 있다. 여기서는 기존 트랜잭션에 참여했기 때문에 신규 트랜잭션이 아니다. (false)
로직 2가 사용되고, 커넥션이 필요한 경우 트랜잭션 동기화 매니저를 통해 외부 트랜잭션이 보관한 커넥션을 획득해서 사용한다.

응답 흐름 - 내부 트랜잭션

로직 2가 끝나고 트랜잭션 매니저를 통해 내부 트랜잭션을 커밋하다.
트랜잭션 매니저는 커밋 시점에 신규 트랜잭션 여부에 따라 다르게 동작한다. 이 경우 신규 트랜잭션이 아니기 때문에 실제 커밋을 호출하지 않는다. 이 부분이 중요한데, 실제 커넥션에 커밋이나 롤백을 호출하면 물리 트랜잭션이 끝나버린다. 아직 트랜잭션이 끝난 것이 아니기 때문에 실제 커밋을 호출함녀 안된다. 물리 트랜잭션은 외부 트랜잭션을 종료할 때 까지 이어져야 한다.

응답 흐름 - 외부 트랜잭션

로직 1이 끝나고 트랜잭션 매니저를 통해 외부 트랜잭션을 커밋한다.
트랜잭션 매니저는 커밋 시점에 신규 트랜잭션 여부에 따라 다르게 동작한다. 외부 트랜잭션은 신규 트랜잭션이다. 따라서 DB 커넥션에 실제 커밋을 호출한다.
트랜잭션 매니저에 커밋하는 것이 논리적인 커밋이라면, 실제 커넥션에 커밋하는 것을 물리 커밋이라 할 수 있다. 실제 데이터베이스에 커밋이 반영되고, 물리 트랜잭션도 끝난다.

핵심 정리

여기서 핵심은 트랜잭션 매니저에 커밋을 호출한다고 해서 항상 실제 커넥션에 물리 커밋이 발생하지는 않는다는 점이다.
신규 트랜잭션인 경우에만 실제 커넥션을 사용해서 물리 커밋과 롤백을 수행한다. 신규 트랜잭션이 아니면 실제 물리 커넥션을 사용하지 않는다.
이렇게 트랜잭션이 내부에서 추가로 사용되면 트랜잭션 매니저에 커밋하는 것이 항상 물리 트랜잭션 커밋으로 이어지지않는다. 그래서 이 경우 논리 트랜잭션과 물리 트랜잭션을 나누게 된다. 또는 외부 트랜잭션과 내부 트랜잭션으로 나누어 설명하기도 한다.
트랜잭션이 내부에서 추가로 사용되면, 트랜잭션 매니저를 통해 논리 트랜잭션을 관리하고, 모든 논리 트랜잭션이 커밋되면 물리 트랜잭션이 커밋된다고 이해하면 된다.

스프링 트랜잭션 전파5 - 외부 롤백

내부 트랜잭션은 커밋되는데, 외부 트랜잭션이 롤백되는 상황

논리 트랜잭션이 하나라도 롤백되면 전체 물리 트랜잭션은 롤백된다.

따라서 이 경우 내부 트랜잭션이 커밋했어도, 내부 트랜잭션 안에서 저장한 데이터도 모두 함께 롤백된다.

2026-01-20T18:41:50.911+09:00  INFO 1498 --- [springtx] [    Test worker] study.springtx.propagation.BasicTxTest   : 외부 트랜잭션 시작
2026-01-20T18:41:50.912+09:00 DEBUG 1498 --- [springtx] [    Test worker] o.s.j.d.DataSourceTransactionManager     : Creating new transaction with name [null]: PROPAGATION_REQUIRED,ISOLATION_DEFAULT
2026-01-20T18:41:50.913+09:00 DEBUG 1498 --- [springtx] [    Test worker] o.s.j.d.DataSourceTransactionManager     : Acquired Connection [HikariProxyConnection@1267443383 wrapping conn0: url=jdbc:h2:mem:5e947c8b-2075-4761-abec-7d57e48b9419 user=SA] for JDBC transaction
2026-01-20T18:41:50.913+09:00 DEBUG 1498 --- [springtx] [    Test worker] o.s.j.d.DataSourceTransactionManager     : Switching JDBC Connection [HikariProxyConnection@1267443383 wrapping conn0: url=jdbc:h2:mem:5e947c8b-2075-4761-abec-7d57e48b9419 user=SA] to manual commit
2026-01-20T18:41:50.914+09:00  INFO 1498 --- [springtx] [    Test worker] study.springtx.propagation.BasicTxTest   : outer.isNewTransaction()=true


2026-01-20T18:41:50.914+09:00  INFO 1498 --- [springtx] [    Test worker] study.springtx.propagation.BasicTxTest   : 내부 트랜잭션 시작
2026-01-20T18:41:50.914+09:00 DEBUG 1498 --- [springtx] [    Test worker] o.s.j.d.DataSourceTransactionManager     : Participating in existing transaction
2026-01-20T18:41:50.914+09:00  INFO 1498 --- [springtx] [    Test worker] study.springtx.propagation.BasicTxTest   : inner.isNewTransaction()=false
2026-01-20T18:41:50.914+09:00  INFO 1498 --- [springtx] [    Test worker] study.springtx.propagation.BasicTxTest   : 내부 트랜잭션 커밋


2026-01-20T18:41:50.914+09:00  INFO 1498 --- [springtx] [    Test worker] study.springtx.propagation.BasicTxTest   : 외부 트랜잭션 롤백
2026-01-20T18:41:50.914+09:00 DEBUG 1498 --- [springtx] [    Test worker] o.s.j.d.DataSourceTransactionManager     : Initiating transaction rollback
2026-01-20T18:41:50.914+09:00 DEBUG 1498 --- [springtx] [    Test worker] o.s.j.d.DataSourceTransactionManager     : Rolling back JDBC transaction on Connection [HikariProxyConnection@1267443383 wrapping conn0: url=jdbc:h2:mem:5e947c8b-2075-4761-abec-7d57e48b9419 user=SA]
2026-01-20T18:41:50.914+09:00 DEBUG 1498 --- [springtx] [    Test worker] o.s.j.d.DataSourceTransactionManager     : Releasing JDBC Connection [HikariProxyConnection@1267443383 wrapping conn0: url=jdbc:h2:mem:5e947c8b-2075-4761-abec-7d57e48b9419 user=SA] after transaction

외부 트랜잭션이 물리 트랜잭션을 시작하고 롤백하는 것을 확인할 수 있다.
내부 트랜잭션은 직접 물리 트랜잭션에 관여하지 않는다.
결과적으로 외부 트랜잭션에서 시작한 물리 트랜잭션의 범위가 내부 트랜잭션까지 사용된다. 이후 외부 트랜잭션이 롤백되면서 전체 내용은 모두 롤백된다.

응답 흐름

요청흐름은 위아 같아 생략

응답 흐름 - 내부 트랜잭션

로직2가 끝나고 트랜잭션 매니저를 통해 내부 트랜잭션을 커밋한다.
트랜잭션 매니저는 커밋 시점에 신규 트랜잭션 여부에 따라 다르게 동작한다. 이 경우 신규 트랜잭션이 아니기 때문에 실제 커밋을 호출하지 않는다. 실제 커넥션에 커밋이나 롤백을 호출하면 물리 트랜잭션이 끝나버린다. 아직 트랜잭션이 끝난 것이 아니기 때문에 실제 커밋을 호출하면 안된다. 물리 트랜잭션은 외부 트랜잭션을 종료할 때 까지 이어져야 한다.

응답 흐름 - 외부 트랜잭션

로직1이 끝나고 트랜잭션 매니저를 통해 외부 트랜잭션을 롤백한다.
트랜잭션 매니저는 롤백 시점에 신규 트랜잭션 여부에 따라 다르게 동작한다. 외부 트랜잭션은 신규 트랜잭션이다. 따라서 DB커넥션에 롤백을 호출한다.
트랜잭션 매니저에 롤백하는 것이 논리적인 롤백이라면, 실제 커넥션에 롤백하는 것을 물리 롤백이라 할 수 있다.
실제 데이터베이스에 롤백이 반영되고, 물리 트랜잭션도 끝난다.

스프링 트랜잭션 전파6 - 내부 롤백

내부 트랜잭션은 롤백되는데, 외부 트랜잭션이 커밋되는 상황

이 상황은 겉으로 보기에 단순하지만, 실제로는 단순하지 않다. 내부 트랜잭션이 롤백을 했지만, 내부 트랜잭션은 물리 트랜잭션에 영향을 주지 않는다. 그런데 외부 트랜잭션은 커밋을 해버린다. 지금까지 학습한 내용을 돌아보면 외부 트랜잭션만 물리 트랜잭션에 영향을 주기 때문에 물리 트랜잭션이 커밋될 것 같다.

전체를 롤백해야 하는데, 스프링은 이 문제를 어떻게 해결할까?

2026-01-20T19:00:39.602+09:00  INFO 1601 --- [springtx] [    Test worker] study.springtx.propagation.BasicTxTest   : Started BasicTxTest in 0.935 seconds (process running for 1.335)
2026-01-20T19:00:39.807+09:00  INFO 1601 --- [springtx] [    Test worker] study.springtx.propagation.BasicTxTest   : 외부 트랜잭션 시작
2026-01-20T19:00:39.807+09:00 DEBUG 1601 --- [springtx] [    Test worker] o.s.j.d.DataSourceTransactionManager     : Creating new transaction with name [null]: PROPAGATION_REQUIRED,ISOLATION_DEFAULT
2026-01-20T19:00:39.808+09:00 DEBUG 1601 --- [springtx] [    Test worker] o.s.j.d.DataSourceTransactionManager     : Acquired Connection [HikariProxyConnection@1682034673 wrapping conn0: url=jdbc:h2:mem:311cf42a-f586-4ec5-9e20-436e45f341ad user=SA] for JDBC transaction
2026-01-20T19:00:39.809+09:00 DEBUG 1601 --- [springtx] [    Test worker] o.s.j.d.DataSourceTransactionManager     : Switching JDBC Connection [HikariProxyConnection@1682034673 wrapping conn0: url=jdbc:h2:mem:311cf42a-f586-4ec5-9e20-436e45f341ad user=SA] to manual commit


2026-01-20T19:00:39.809+09:00  INFO 1601 --- [springtx] [    Test worker] study.springtx.propagation.BasicTxTest   : 내부 트랜잭션 시작
2026-01-20T19:00:39.809+09:00 DEBUG 1601 --- [springtx] [    Test worker] o.s.j.d.DataSourceTransactionManager     : Participating in existing transaction
2026-01-20T19:00:39.809+09:00  INFO 1601 --- [springtx] [    Test worker] study.springtx.propagation.BasicTxTest   : 내부 트랜잭션 롤백
2026-01-20T19:00:39.809+09:00 DEBUG 1601 --- [springtx] [    Test worker] o.s.j.d.DataSourceTransactionManager     : Participating transaction failed - marking existing transaction as rollback-only
2026-01-20T19:00:39.809+09:00 DEBUG 1601 --- [springtx] [    Test worker] o.s.j.d.DataSourceTransactionManager     : Setting JDBC transaction [HikariProxyConnection@1682034673 wrapping conn0: url=jdbc:h2:mem:311cf42a-f586-4ec5-9e20-436e45f341ad user=SA] rollback-only


2026-01-20T19:00:39.809+09:00  INFO 1601 --- [springtx] [    Test worker] study.springtx.propagation.BasicTxTest   : 외부 트랜잭션 커밋
2026-01-20T19:00:39.822+09:00 DEBUG 1601 --- [springtx] [    Test worker] o.s.j.d.DataSourceTransactionManager     : Global transaction is marked as rollback-only but transactional code requested commit
2026-01-20T19:00:39.822+09:00 DEBUG 1601 --- [springtx] [    Test worker] o.s.j.d.DataSourceTransactionManager     : Initiating transaction rollback
2026-01-20T19:00:39.822+09:00 DEBUG 1601 --- [springtx] [    Test worker] o.s.j.d.DataSourceTransactionManager     : Rolling back JDBC transaction on Connection [HikariProxyConnection@1682034673 wrapping conn0: url=jdbc:h2:mem:311cf42a-f586-4ec5-9e20-436e45f341ad user=SA]
2026-01-20T19:00:39.823+09:00 DEBUG 1601 --- [springtx] [    Test worker] o.s.j.d.DataSourceTransactionManager     : Releasing JDBC Connection [HikariProxyConnection@1682034673 wrapping conn0: url=jdbc:h2:mem:311cf42a-f586-4ec5-9e20-436e45f341ad user=SA] after transaction

실행 결과를 보면 마지막에 외부 트랜잭션을 커밋할 때 UnexpectedRollbackException.class가 발생한다.

외부 트랜잭션 시작
- 물리 트랜잭션을 시작한다.
내부 트랜잭션 시작
- Participating in existing transaction
- 기존 트랜잭션에 참여한다.
내부 트랜잭션 롤백
- Participating transaction failed - marking existing transaction as rollback-only
- 내부 트랜잭션을 롤백하면 실제 물리 트랜잭션은 롤백하지 않는다. 대신에 기존 트랜잭션을 롤백 전용으로 표시한다.
외부 트랜잭션 커밋
- 외부 트랜잭션을 커밋한다.
- Global transaction is marked as rollback-only but transactional code requested commit
- 커밋을 호출했지만, 전체 트랜잭션이 롤백 전용으로 표시되어 있다. 따라서 물리 트랜잭션을 롤백한다.

응답 흐름 - 내부 트랜잭션

로직2가 끝나고 트랜잭션 매니저를 통해 내부 트랜잭션을 롤백한다. (로직2에 문제가 있어서 롤백한다고 정한다.)
트랜잭션 매니저는 롤백 시점에 신규 트랜잭션 여부에 따라 다르게 동작한다. 이 경우 신규 트랜잭션이 아니기 때문에 실제 롤백을 호출하지 않느다. 실제 커넥션에 커밋이나 롤백을 호출하면 물리 트랜잭션이 끝나버린다. 아직 트랜잭션이 끝난 것이 아니기 때문에 실제 롤백을 호출하면 안된다. 물리 트랜잭션은 외부 트랜잭션을 종료할 때 까지 이어져야 한다.
내부 트랜잭션을 물리 트랜잭션을 롤백하지 않는 대신에 트랜잭션 동기화 매니저에 rollbakOnly=true라는 표시를 해둔다.

응답 흐름 - 외부 트랜잭션

로직 1이 끝나고 트랜잭션 매니저를 통해 외부 트랜잭션을 커밋한다.
트랜잭션 매니저는 커밋 시점에 신규 트랜잭션 여부에 따라 다르게 동작한다. 외부 트랜잭션은 신규 트랜잭션이다.
따라서 DB커넥션에 실제 커밋을 호출해야한다. 이때 먼저 트랜잭션 동기화 매니저에 롤백 전용(`rollbackOnly=true` ) 표시가 있는지 확인한다. 롤백 전용 표시가 있으면 물리 트랜잭션을 커밋하는 것이 아니라 롤백한다.
실제 데이터베이스에 롤백에 반영되고, 물리 트랜잭션도 끝난다.
트랜잭션 매니저에 커밋을 호출한 개발자 입장에서 분명 커밋을 기대했는데 롤백 전용 표시로 인해 실제로는 롤백되어 버렸다.
1. 이것은 조용히 넘어 갈 수 있는 문제가 아니다. 시스템 입장에서는 커밋을 호출했지만, 롤백이 되었다는 것은 분명하게 알려줘야 한다.
2. 예를 들어 고객이 주문이 성공했다고 생각했는데, 실제로를 롤백이 되어 주문이 생성되지 않는다.
3. 스프링은 이 경우`UnexpectedRollbackException` 런타임 예외를 던진다. 그래서 커밋을 시도했지만, 기대하지 않은 롤백이 발생하는 것을 명확하게 알려준다.

정리

논리 트랜잭션이 하나라도 롤백되면 물리 트랜잭션은 롤백된다.
내부 논리 트랜잭션이 롤백되면 롤백 전용 마크를 표시한다.
외부 트랜잭션을 커밋할 때 롤백 전용 마크를 확인한다. 롤백 전용 마크가 표시되어 있으면 물리 트랜잭션을 롤백하고, `UnexpectedRollbackException` 예외를 던진다.

참고

애플리케이션 개발에서 중요한 기본 원칙은 모호함을 제거하는 것이다. 개발은 명확해야 한다. 이렇게 커밋을 호출했는데, 내부에서 롤백이 발생한 경우 모호하게 두면 아주 심각한 문제가 발생한다. 이렇게 기대한 결과가 다른 경우 예외를 발생시켜서 명확하게 문제를 알려주는 것이 좋다.

스프링 트랜잭션 전파7 - REQUIRES_NEW

외부 트랜잭션과 내부 트랜잭션을 완전히 분리해서 사용하는 방법에 대해 알아보자.

외부 트랜잭션과 내부 트랜잭션을 완전히 분리해서 각각 별도의 물리 트랜잭션을 사용하는 방법이다. 그래서 커밋과 롤백도 각각 별도로 이루어지게 된다.

이 방법은 내부 트랜잭션에 문제가 발생해서 롤백해도, 외부 트랜잭션에 영향을 주지 않는다. 반대로 외부 트랜잭션에 문제가 발생해도 내부 트랜잭션에 영향을 주지 않는다.

동작원리

이렇게 물리 트랜잭션을 분리하려면 내부 트랜잭션을 시작할 때 REQUIRES_NEW 옵션을 사용하면 된다.
외부 트랜잭션과 내부 트랜잭션이 각각 별도의 물리 트랜잭션을 가진다.
별도의 물리 트랜잭션을 가진다는 뜻은 DB커넥션을 따로 사용한다는 뜻이다.
이 경우 내부 트랜잭션이 롤백되면서 로직2가 롤백되어도 로직 1에서 저장한 데이터는 영향을 주지 않는다.
최종적으로 로직2는 롤백되고, 로직1은 커밋된다.

    @Test
    void inner_rollback_requires_new() {
        log.info("외부 트랜잭션 시작");
        TransactionStatus outer = transactionManager.getTransaction(new DefaultTransactionAttribute());
        log.info("outer.isNewTransaction()={}", outer.isNewTransaction());

        log.info("내부 트랜잭션 시작");
        DefaultTransactionAttribute definition = new DefaultTransactionAttribute();
        definition.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
        TransactionStatus inner = transactionManager.getTransaction(definition);
        log.info("inner.isNewTransaction()={}", inner.isNewTransaction());

        log.info("내부 트랜잭션 롤백");
        transactionManager.rollback(inner);

        log.info("외부 트랜잭션 커밋");
        transactionManager.commit(outer);
    }

내부 트랜잭션을 시작할 때 전파옵션인 `propagationBehavior` 에 PROPAGATION_REQUIRES_NEW 옵션을 주었다.
이 전파 옵션을 사용하면 내부 트랜잭션을 시작할 때 기존 트랜잭션에 참여하는 것이 아니라 새로운 물리 트랜잭션을 만들어서 시작하게 된다.

실행 결과 -inner_rollback_requires_new()

2026-01-22T23:00:46.530+09:00  INFO 1379 --- [springtx] [    Test worker] study.springtx.propagation.BasicTxTest   : 외부 트랜잭션 시작
2026-01-22T23:00:46.531+09:00 DEBUG 1379 --- [springtx] [    Test worker] o.s.j.d.DataSourceTransactionManager     : Creating new transaction with name [null]: PROPAGATION_REQUIRED,ISOLATION_DEFAULT
2026-01-22T23:00:46.531+09:00 DEBUG 1379 --- [springtx] [    Test worker] o.s.j.d.DataSourceTransactionManager     : Acquired Connection [HikariProxyConnection@1821332066 wrapping conn0: url=jdbc:h2:mem:c416d5dd-f0ae-4714-91bd-b177dad29704 user=SA] for JDBC transaction
2026-01-22T23:00:46.532+09:00 DEBUG 1379 --- [springtx] [    Test worker] o.s.j.d.DataSourceTransactionManager     : Switching JDBC Connection [HikariProxyConnection@1821332066 wrapping conn0: url=jdbc:h2:mem:c416d5dd-f0ae-4714-91bd-b177dad29704 user=SA] to manual commit
2026-01-22T23:00:46.532+09:00  INFO 1379 --- [springtx] [    Test worker] study.springtx.propagation.BasicTxTest   : outer.isNewTransaction()=true


2026-01-22T23:00:46.532+09:00  INFO 1379 --- [springtx] [    Test worker] study.springtx.propagation.BasicTxTest   : 내부 트랜잭션 시작
2026-01-22T23:00:46.533+09:00 DEBUG 1379 --- [springtx] [    Test worker] o.s.j.d.DataSourceTransactionManager     : Suspending current transaction, creating new transaction with name [null]
2026-01-22T23:00:46.533+09:00 DEBUG 1379 --- [springtx] [    Test worker] o.s.j.d.DataSourceTransactionManager     : Acquired Connection [HikariProxyConnection@1290483339 wrapping conn1: url=jdbc:h2:mem:c416d5dd-f0ae-4714-91bd-b177dad29704 user=SA] for JDBC transaction
2026-01-22T23:00:46.533+09:00 DEBUG 1379 --- [springtx] [    Test worker] o.s.j.d.DataSourceTransactionManager     : Switching JDBC Connection [HikariProxyConnection@1290483339 wrapping conn1: url=jdbc:h2:mem:c416d5dd-f0ae-4714-91bd-b177dad29704 user=SA] to manual commit
2026-01-22T23:00:46.533+09:00  INFO 1379 --- [springtx] [    Test worker] study.springtx.propagation.BasicTxTest   : inner.isNewTransaction()=true


2026-01-22T23:00:46.533+09:00  INFO 1379 --- [springtx] [    Test worker] study.springtx.propagation.BasicTxTest   : 내부 트랜잭션 롤백
2026-01-22T23:00:46.533+09:00 DEBUG 1379 --- [springtx] [    Test worker] o.s.j.d.DataSourceTransactionManager     : Initiating transaction rollback
2026-01-22T23:00:46.533+09:00 DEBUG 1379 --- [springtx] [    Test worker] o.s.j.d.DataSourceTransactionManager     : Rolling back JDBC transaction on Connection [HikariProxyConnection@1290483339 wrapping conn1: url=jdbc:h2:mem:c416d5dd-f0ae-4714-91bd-b177dad29704 user=SA]
2026-01-22T23:00:46.533+09:00 DEBUG 1379 --- [springtx] [    Test worker] o.s.j.d.DataSourceTransactionManager     : Releasing JDBC Connection [HikariProxyConnection@1290483339 wrapping conn1: url=jdbc:h2:mem:c416d5dd-f0ae-4714-91bd-b177dad29704 user=SA] after transaction
2026-01-22T23:00:46.534+09:00 DEBUG 1379 --- [springtx] [    Test worker] o.s.j.d.DataSourceTransactionManager     : Resuming suspended transaction after completion of inner transaction


2026-01-22T23:00:46.534+09:00  INFO 1379 --- [springtx] [    Test worker] study.springtx.propagation.BasicTxTest   : 외부 트랜잭션 커밋
2026-01-22T23:00:46.534+09:00 DEBUG 1379 --- [springtx] [    Test worker] o.s.j.d.DataSourceTransactionManager     : Initiating transaction commit
2026-01-22T23:00:46.534+09:00 DEBUG 1379 --- [springtx] [    Test worker] o.s.j.d.DataSourceTransactionManager     : Committing JDBC transaction on Connection [HikariProxyConnection@1821332066 wrapping conn0: url=jdbc:h2:mem:c416d5dd-f0ae-4714-91bd-b177dad29704 user=SA]
2026-01-22T23:00:46.534+09:00 DEBUG 1379 --- [springtx] [    Test worker] o.s.j.d.DataSourceTransactionManager     : Releasing JDBC Connection [HikariProxyConnection@1821332066 wrapping conn0: url=jdbc:h2:mem:c416d5dd-f0ae-4714-91bd-b177dad29704 user=SA] after transaction

외부 트랜잭션 시작

외부 트랜잭션을 시작하면서 conn0 을 획득하고 manual commit 으로 변경해서 물리 트랜잭션을 시작한다.
외부 트랜잭션은 신규 트랜잭션이다. (outer.isNewTransaction()=true)

내부 트랜잭션 시작

내부 트랜잭션을 시작하면서 conn1 을 획득하고 manual commit 으로 변경해서 물리 트랜잭션을 시작한다.
내부 트랜잭션은 외부 트랜잭션에 참여하는 것이 아니라, PROPAGATION_REQUIRES_NEW 옵션을 사용했기 때문에 완전히 새로운 신규 트랜잭션으로 생성된다. (inner.isNewTransaction()=true)

내부 트랜잭션 롤백

내부 트랜잭션을 롤백한다.
내부 트랜잭션은 신규 트랜잭션이기 때문에 실제 물리 트랜잭션을 롤백한다.
내부 트랜잭션은 conn1을 사용하므로 conn1에 물리 롤백을 수행한다.

외부 트랜잭션 커밋

외부 트랜잭션을 커밋한다.
외부 트랜잭션은 신규 트랜잭션이기 때문에 실제 물리 트랜잭션을 커밋한다.
외부 트랜잭션은 conn0를 사용하므로 conn0에 물리 커밋을 수행한다.

요청 흐름 - 외부 트랜잭션

transactionManager.getTransaction()를 호출해서 외부 트랜잭션을 시작한다.
트랜잭션 매니저는 데이터소스를 통해 커넥션을 생성한다.
생성한 커넥션을 수동 커밋 모드(setAutoCommit(false)) 로 설정한다. - 물리 트랜잭션 시작
트랜잭션 매니저는 트랜잭션 동기화 매니저에 커넥션을 보관한다.
트랜잭션 매니저는 트랜잭션을 생성한 결과를 TransactionStatus 에 담아서 반환하는데, 여기에 신규 트랜잭션의 여부가 담겨 있다.`isNewTransaction` 를 통해 신규 커넥션 여부를 확인할 수 있다. 트랜잭션을 처음 시작했으므로 신규 트랜잭션이다.(isNewTransaction()=true)
로직 1이 사용되고, 커넥션이 필요한 경우 트랜잭션 동기화 매니저를 통해 트랜잭션이 적용된 커넥션을 획득해서 사용한다.

요청 흐름 - 내부 트랜잭션

REQUIRES_NEW 옵션과 함께 transactionManager.getTransaction()를 호출해서 내부 트랜잭션을 시작한다.
트랜잭션 매니저는 REQUIRES_NEW 옵션을 확인하고 기존 트랜잭션에 참여하는 것이 아니라, 새로운 트랜잭션을 시작한다.
트랜잭션 매니저는 데이터소스를 통해 커넥션을 생성한다.
생성한 커넥션을 수동 커밋 모드(setAutoCommit(false)) 로 설정한다. - 물리 트랜잭션 시작
트랜잭션 매니저는 트랜잭션 동기화 매니저에 커넥션을 보관한다.
- 이때 conn1은 잠시 보류되고, 지금부터는 conn2가 사용된다. (내부 트랜잭션이 완료될 때까지 conn2 가 사용된다.)
트랜잭션 매니저는 신규 트랜잭션의 생성 결과를 반환한다.(isNewTransaction()=true)
로직 2가 사용되고, 커넥션이 필요한 경우 트랜잭션 동기화 매니저에 있는 con2 커넥션을 획득해서 사용한다.

응답 흐름 - 내부 트랜잭션

로직2가 끝나고 트랜잭션 매니저를 통해 내부 트랜잭션을 롤백한다. (로직2가 문제가 있어서 롤백한다고 가정)
트랜잭션 매니저는 롤백 시점에 신규 트랜잭션 여부에 따라 다르게 동작한다. 현재 내부 트랜잭션을 신규 트랜잭션이다. 따라서 실제 롤백을 호출한다.
내부 트랜잭션이 con2 물리 트랜잭션을 롤백한다.
- 트랜잭션 종료되고, con2는 종료되거나, 커넥션 풀에 반납된다.
- 이후에 con1의 보류가 끝나고, 다시 con1을 사용한다.

응답 흐름 - 외부 트랜잭션

외부 트랜잭션에 커밋을 요청한다.
외부 트랜잭션은 신규 트랜잭션이기 때문에 물리 트랜잭션을 커밋한다.
이때 rollbackOnly 설정을 체크한다. rollbackOnly 설정이 없으므로 커밋한다.
본인이 만든 con1 커넥션을 통해 물리 트랜잭션을 커밋한다.
- 트랜잭션 종료되고, con1는 종료되거나, 커넥션 풀에 반납된다.

정리

REQUIRES_NEW 옵션을 사용하면 물리 트랜잭션이 명확하게 분리된다.
REQUIRES_NEW 를 사용하면 데이터베이스 커넥션이 동시에 2개 사용된다는 점을 주위해야한다.

참고 자료

스프링 DB 2편 - 데이터 접근 활용 기술

'Spring' 카테고리의 다른 글

스프링 트랜잭션 rollbackFor (1)	2026.01.08
Java 리플렉션과 스프링 DI 동작 원리 정리 : 직접 만들어보며 이해하기 (0)	2025.09.27
프록시와 내부 호출 문제 (@Transactional self-invocation) (0)	2025.09.21
로그인 처리1 - 쿠키, 세션 (0)	2025.08.16
Spring 외부 설정값 주입 방법 총정리 : Environment, @Value, @ConfigurationProperties 비교 (2)	2025.06.11

현재글스프링 트랜잭션 전파 - 커밋, 롤백

뚝딱 뚝딱 개발일기

백준 12886, chain – matrix multiplication problem, 자바의신11~18, Java, 김영한, 자바, realmysql, 백준11049, 자바의 신2, 정리해봅시다, 인프런, 정규식, call by value 와 call by reference, 다양한 의존관계 주입, equals ==, 스프링, 프로그래머스, 스프링컨테이너, 람다식, 행렬곱셈순서,

Today :
Yesterday :

뚝딱 뚝딱 개발일기