[스프링 DB 2편] #10. 스프링 트랜잭션 전파 - 기본

[YONGHYNG]

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

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

package hello.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 txManager;

    @TestConfiguration//해당 테스트에 필요한 스프링 설정을 추가로 할 수 있음
    static class Config {
        @Bean
        /**
         * PlatformTransactionManager를 이용하여 직접 트랜잭션을 시작, 커밋 또는 롤백하는 기능 검증 역할 함
         * */
        public PlatformTransactionManager transactionManager(DataSource dataSource) {
            return new DataSourceTransactionManager(dataSource);
        }
    }

    @Test
    void commit(){
        log.info("트랜잭션 시작");
        /**
         * DataSourceTransactionManager를 스프링 빈으로 등록,
         * 이후 트랜잭셔 매니저인 PlatformTransactionManager 를 주입 받으며 방금 등록한
         * DataSourceTransactionManager가 주입
         *
         * commit()
         * txManager.getTransaction(new DefaultTransactionAttribute())
         * 트랜잭션 매니저를 통해 트랜잭션을 시작(획득)
         * */
        TransactionStatus status = txManager.getTransaction(new DefaultTransactionAttribute());

        log.info("트랜잭션 커밋 시작");
        txManager.commit(status); //트랜잭션을 커밋
        log.info("트랜잭션 커밋 완료");
    }

    @Test
    void rollback(){
        log.info("트랜잭션 시작");
        TransactionStatus status = txManager.getTransaction(new DefaultTransactionAttribute());

        log.info("트랜잭션 롤백 시작");
        txManager.rollback(status);
        log.info("트랜잭션 롤백 완료");
    }
}

commit() - 실행 로그

rollback()
txManager.getTransaction(new DefaultTransactionAttribute())
-트랜잭션 매니저를 통해 트랜잭션을 시작, 획득함

txManager.rollback(status)
-트랜잭션을 롤백함

rollback() - 실행 로그

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

• 이번에는 트랜잭션이 각각 따로 사용되는 경우

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

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

double_commit() - 실행 로그

트랜잭션1

• Acquired Connection [HikariProxyConnection@1064414847 wrapping conn0] for JDBC transaction
• 트랜잭선1을 시작하고, 커넥션 풀에서 conn0 커넥션을 획득
• Acquired Connection [HikariProxyConnection@1064414847 wrapping conn0] for JDBC transaction
• 트랜잭션1을 커밋하고, 커넥션 풀에 conn0 커넥션을 반납

트랜잭션2

• Acquired Connection [HikariProxyConnection@ 778350106 wrapping conn0] for JDBC transaction
• 트랜잭션2을 시작, 커넥션 풀에서 conn0 커넥션을 획득
• Releasing JDBC Connection [HikariProxyConnection@ 778350106 wrapping conn0] after transaction
• 트랜잭션2을 커밋, 커넥션 풀에 conn0 커넥션 반납

주의

• 로그를 보면 트랜잭션1과 트랜잭션2가 같은 conn0 커넥션 사용중, 중간에 커넥션 풀 때문에 그런 것
• 트랜잭션1은 conn0 커넥션을 모두 사용하고 커넥션 풀에 반납까지 완료
• 이후, 트랜잭션2가 conn0을 커넥션 풀에서 획득, 따라서 둘은 완전히 다른 커넥션으로 인지하는 것이 맞음

구분하는 방법

• 트랜잭션1 : Acquired Connection [HikariProxyConnection@1000000 wrapping conn0]

• 트랜잭션2 : Acquired Connection [HikariProxyConnection@2000000 wrapping conn0]

• 트랜잭션1과 트랜잭션2 값이 서로 다른 것을 확인할 수 있음

• 결과적으로 conn0을 통해 커넥션 재사용 된 것을 확인할 수 있고, HikariProxyConnection@1000000 ,
  HikariProxyConnection@2000000 을 통해 각각 커넥션 풀에서 커넥션을 조회한 것을 확인 가능

• 트랜잭션이 각각 수행되면서 사용되는 DB 커넥션도 다름
• 이 경우 트랜잭션을 각자 관리하기 때문에 전체 트랜잭션을 묶을 수 없음, 예를 들어서 트랜잭션1이 커밋하고, 트랜잭션2가 롤백하는 경우 트랜잭션1에서 저장한 데이터는 커밋, 트랜잭션2에서 저장한 데이터는 롤백 됨

double_commit_rollback() - BasicTxTest 추가

    @Test
    void double_commit_rollback(){ //2개의 트랜잭션은 완전히 독립적

        log.info("트랜잭션1 시작");
        TransactionStatus tx1 = txManager.getTransaction(new DefaultTransactionAttribute());
        log.info("트랜잭션1 커밋");
        txManager.commit(tx1);

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

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

double_commit_rollback() - 실행 로그

트랜잭션1 시작
Creating new transaction with name [null]: 
PROPAGATION_REQUIRED,ISOLATION_DEFAULT
Acquired Connection [HikariProxyConnection@1943867171 wrapping conn0] for JDBC 
transaction
Switching JDBC Connection [HikariProxyConnection@1943867171 wrapping conn0] to 
manual commit
트랜잭션1 커밋
Initiating transaction commit
Committing JDBC transaction on Connection [HikariProxyConnection@1943867171 
wrapping conn0]
Releasing JDBC Connection [HikariProxyConnection@1943867171 wrapping conn0] 
after transaction
트랜잭션2 시작
Creating new transaction with name [null]: 
PROPAGATION_REQUIRED,ISOLATION_DEFAULT
Acquired Connection [HikariProxyConnection@239290560 wrapping conn0] for JDBC 
transaction
Switching JDBC Connection [HikariProxyConnection@239290560 wrapping conn0] to 
manual commit
트랜잭션2 롤백
Initiating transaction rollback
Rolling back JDBC transaction on Connection [HikariProxyConnection@239290560 
wrapping conn0]
Releasing JDBC Connection [HikariProxyConnection@239290560 wrapping conn0] after 
transaction

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

• 트랜잭션이 이미 진행중인데, 여기에 추가로 트랜잭션을 수행하면 어떻게 될까?
• 이런 경우 어떻게 동작할지 결정하는 것을 트랜잭션 전파(propagation)라 함, 스프링은 다양한 트랜잭션 옵션 제공

트랜잭션 전파 기본 옵션 REQUIRED 기준

외부 트랜잭션이 수행중인데, 내부 트랜잭션이 추가로 수행됨

• 외부(첫 번째) 트랜잭션이 수행중이고, 아직 끝나지 않았는데 내부(두 번째) 트랜잭션이 수행

• 스프링에서 이 경우 외부 트랜잭션과 내부 트랜잭션을 묶어 하나의 트랜잭션을 만들어줌
• 내부 트랜잭션이 외부 트랜잭션에 참여, 이것이 기본 동작, 옵션을 통해 다른 동작방식 선택 가능

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

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

원칙

• 모든 논리 트랜잭션이 커밋되어야 물리 트랜잭션이 커밋됨
• 하나의 논리 트랜잭션이라도 롤백되면 물리 트랜잭션은 롤백 됨

• 모든 논리 트랜잭션이 커밋 되면 물리 트랜잭션도 커밋

• 외부 논리 트랜잭션이 롤백되면 물리 트랜잭션은 롤백 됨

• 내부 논리 트랜잭션이 롤백 되므로 물리 트랜잭션은 롤백 됨

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

innter_commit() - BasicTxTest 추가

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

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

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

• 외부 트랜잭션이 수행중인데, 내부 트랜잭션을 추가로 수행
• 외부 트랜잭션은 처음 수행된 트랜잭션, 이 경우 신규 트랜잭션(isNewTransaction=true)가 됨
• 내부 트랜잭션을 시작하는 시점에는 이미 외부 트랜잭션이 진행중인 상태, 이 경우 내부 트랜잭션은 외부 트랜잭션에 참여
• 내부 트랜잭션은 이미 진행중인 외부 트랜잭션에 참여, 이 경우 신규 트랜잭션이 아님(isNew)

트랜잭션 참여

• 내부 트랜잭션이 외부 트랜잭션에 참여한다는 뜻은 내부 트랜잭션이 외부 트랜잭션을 이어 받아서 따름

• 다른 관점으로 보면 외부 트랜잭션의 범위가 내부 트랜잭션까지 넓어진다는 뜻

• 외부에서 시작된 물리적인 트랜잭션의 범위가 내부 트랜잭션까지 넓어진다는 뜻

• 정리하면 외부 트랜잭션과 내부 트랜잭션이 하나의 물리 트랜잭션으로 묶임

• 그런데 코드를 잘 보면 커밋을 두 번 호출, 트랜잭션을 생각해보면 하나의 커넥션에 커밋은 한 번만 호출, 커밋이나 롤백을 하면 해당 트랜잭션은 끝남

txManager.commit(inner);
txManager.commit(outer);

실행 결과 - inner_commit()

외부 트랜잭션 시작
Creating new transaction with name [null]: 
PROPAGATION_REQUIRED,ISOLATION_DEFAULT
Acquired Connection [HikariProxyConnection@1943867171 wrapping conn0] for JDBC 
transaction
Switching JDBC Connection [HikariProxyConnection@1943867171 wrapping conn0] to 
manual commit
outer.isNewTransaction()=true
내부 트랜잭션 시작
Participating in existing transaction
inner.isNewTransaction()=false
내부 트랜잭션 커밋
외부 트랜잭션 커밋
Initiating transaction commit
Committing JDBC transaction on Connection [HikariProxyConnection@1943867171 
wrapping conn0]
Releasing JDBC Connection [HikariProxyConnection@1943867171 wrapping conn0] 
after transaction

• 내부 트랜잭션을 시작할 때 Participating in existing transaction 메시지 확인 가능하다, 이 메시지는 내부 트랜잭션이 기존에 존재하는 외부 트랜잭션에 참여한다는 뜻
• 실행 결과를 보면 외부 트랜잭션을 시작하거나 커밋할 때는 DB 커넥션을 통한 물리 트랜잭션을 시작(manual commit)하고, DB 커넥션을 통해 커밋 하는 것을 확인, 그런데 내부 트랜잭션을 시작하거나 커밋할 때는 DB 커넥션을 통해 커밋하는 로그 전혀 확인 불가능
• 정리하면 외부 트랜잭션만 물리 트랜잭션을 시작하고 커밋 함
• 만약 내부 트랜잭션이 실제 물리 트랜잭션을 커밋하면 트랜잭션이 끝나버리기 때문에, 트랜잭션을 처음 시작한 외부 트랜잭션까지 이어갈 수 없음, 따라서 내부 트랜잭션은 DB 커넥션을 통한 물리 트랜잭션을 커밋하면 안 됨
• 스프링은 여러 트랜잭션이 함께 사용되면, 처음 트랜잭션을 시작한 외부 트랜잭션이 실제 물리 트랜잭션을 관리하도록 함, 이를 통해 트랜잭션 중복 커밋 문제 해결함

실제 동작하는 트랜잭션 전파

요청 흐름 - 외부 트랜잭션

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

요청 흐름 - 내부 트랜잭션

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

응답 흐름 - 내부 트랜잭션

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

응답 흐름 - 외부 트랜잭션

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

핵심 정리

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

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

• 내부 트랜잭션은 커밋되는데, 외부 트랜잭션이 롤백되는 상황을 봐보자

• 논리 트랜잭션이 하나라도 롤백되면 전체 물리 트랜잭션은 롤백 됨
• 이 경우 내부 트랜잭션이 커밋했어도, 내부 트랜잭션 안에서 저장한 데이터 모두 롤백 됨

outer_rollback() - BasicTxTest 추가

@Test
        void outer_rollback(){
            log.info("외부 트랜잭션 시작");
            TransactionStatus outer = txManager.getTransaction(new DefaultTransactionAttribute());

            log.info("내부 트랜잭션 시작");
            TransactionStatus inner = txManager.getTransaction(new DefaultTransactionAttribute());

            log.info("내부 트랜잭션 커밋");
            txManager.commit(inner);

            log.info("외부 트랜잭션 롤백");
            txManager.rollback(outer);
        }

실행 결과 - outer_rollback()

• 외부 트랜잭션이 물리 트랜잭션을 시작하고 롤백하는 것 확인 가능
• 내부 트랜잭션은 앞서 배운대로 직접 물리 트랜잭션에 관여하지 않음
• 결과적으로 외부 트랜잭션에서 시작한 물리 트랜잭션의 범위가 내부 트랝개션까지 사용, 이후 외부 트랜잭션이 롤백되면서 전체 내용 모두 롤백 됨

응답 흐름

응답 흐름 - 내부 트랜잭션

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

응답 흐름 - 외부 트랜잭션

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

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

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

• 내부 트랜잭션이 롤백을 했지만, 내부 트랜잭션은 물리 트랜잭션에 영향 주지 않음, 그런데 외부 트랜잭션은 커밋 해버림, 지금까지 학습은 외부 트랜잭션만 물리 트랜잭션에 영향을 주기 떄문에 물리 트랜잭션이 커밋될 것 같음, 이 문제 해결은?

        @Test
        void inner_rollback(){
            log.info("외부 트랜잭션 시작");
            TransactionStatus outer = txManager.getTransaction(new DefaultTransactionAttribute());

            log.info("외부 트랜잭션 시작");
            TransactionStatus inner = txManager.getTransaction(new DefaultTransactionAttribute());
            log.info("내부 트랜잭션 롤백");
            txManager.rollback(inner);

            log.info("외부 트랜잭션 커밋");
            assertThatThrownBy(() -> txManager.commit(outer))
                    .isInstanceOf(UnexpectedRollbackException.class);
        }

외부 트랜잭션 시작
Creating new transaction with name [null]: 
PROPAGATION_REQUIRED,ISOLATION_DEFAULT
Acquired Connection [HikariProxyConnection@220038608 wrapping conn0] for JDBC 
transaction
Switching JDBC Connection [HikariProxyConnection@220038608 wrapping conn0] to 
manual commit
내부 트랜잭션 시작
Participating in existing transaction
내부 트랜잭션 롤백
Participating transaction failed - marking existing transaction as rollback-only
Setting JDBC transaction [HikariProxyConnection@220038608 wrapping conn0] 
rollback-only
외부 트랜잭션 커밋
Global transaction is marked as rollback-only but transactional code requested 
commit
Initiating transaction rollback
Rolling back JDBC transaction on Connection [HikariProxyConnection@220038608 
wrapping conn0]
Releasing JDBC Connection [HikariProxyConnection@220038608 wrapping conn0] after 
transaction

• 외부 트랜잭션 시작 : 물리 트랜잭션 시작
• 내부 트랜잭션 시작 : Participating in existing transaction, 기존 트랜잭션에 참여
• 내부 트랜잭션 롤백 : Participating transaction failed - marking existing transaction as rollback-only, 내부 트랜잭션을 롤백하면 실제 물리 트랜잭션은 롤백하지 않음, 대신에 기존 트랜잭션을 롤백 전용으로 표시
• 외부 트랜잭션 커밋 : 외부 트랜잭션을 커밋함,Global transaction is marked as rollback-only, 커밋을 호출했지만, 전체 트랜잭션이 롤백 전용으로 표시, 따라서 물리 트랜잭션 롤백

응답 흐름 - 내부 트랜잭션

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

응답 흐름 - 외부 트랜잭션

• 4. 로직 1이 끝나고 트랜잭션 매니저를 통해 외부 트랜잭션을 커밋함
• 5. 트랜잭션 매니저는 커밋 시점에 신규 트랜잭션 여부에 따라 다르게 동작, 외부 트랜잭션은 신규 트랜잭션, 따라서 DB 커넥션에 실제 커밋을 호출, 이때 먼저 트랜잭션 동기화 ㅐ니저에 롤백 전용(rollbackOnly = true) 표시가 있는지 확인, 롤백 전용 표시가 있으면 물리 트랜잭션을 커밋하는 것이 아니라 롤백함
• 6. 실제 DB는 롤백이 반영, 물리 트랜잭션도 끝남
• 7. 트랜잭션 매니저에 커밋을 호출한 개발자 입장에서는 분명 커밋을 기대했는데, 롤백 전용 표시로 인해 실제로는 롤백이 되어버림(시스템 입장에서는 커밋을 호출했지만 롤백이 되었다는 것을 알려주어야 함)
• 8. 스프링은 이 경우 UnexpectedRollbackException 런타임 예외를 던짐, 그래서 커밋을 시도했지만, 기대하지 않은 롤백이 발생했다는 것을 명확하게 알려야 함

정리

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

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

• 외부 트랜잭션과 내부 트랜잭션을 완전히 분리해서 사용하는 방법에 대해 알아보자
• 외부 트랜잭션과 내부 트랜잭션을 완전히 분리해서 각각 별도의 물리 트랜잭션을 사용하는 방법, 그래서 커밋과 롤백도 각각 별도로 이루어짐
• 이 방법은 내부 트랜잭션에 문제가 발생해서 롤백해도, 외부 트랜잭션에 영향 주지 않음
• 반대로 외부 트랜잭션에 문제가 발생해도 내부 트랜잭션에 영향 주지 않음

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

inner_rollback_requires_new()-BasicTxTest 추가

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

            log.info("내부 트랜잭션 시작");
            DefaultTransactionAttribute definition = new DefaultTransactionAttribute();

            /**
             * 내부 트랜잭션을 시작할 때 전파 옵션인 propagationBehavior
             * PROPAGATION_REQUIRES_NEW 옵션을 내줌
             * 이 전파 옵션을 사용하면 내부 느랜잭션을 시작할 떄 기준 트랜잭션에 참여하는 것이 아니라 새로운
             * 물리 트랜잭션을 만들어서 시작함
             * */
            definition.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);

            TransactionStatus inner = txManager.getTransaction(definition);
            log.info("inner.isNewTransaction()={}", inner.isNewTransaction());

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

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

실행 결과 - inner_rollback_requires_new()

외부 트랜잭션 시작
Creating new transaction with name [null]: 
PROPAGATION_REQUIRED,ISOLATION_DEFAULT
Acquired Connection [HikariProxyConnection@1064414847 wrapping conn0] for JDBC 
transaction
Switching JDBC Connection [HikariProxyConnection@1064414847 wrapping conn0] to 
manual commit
outer.isNewTransaction()=true
내부 트랜잭션 시작
Suspending current transaction, creating new transaction with name [null]
Acquired Connection [HikariProxyConnection@778350106 wrapping conn1] for JDBC 
transaction
Switching JDBC Connection [HikariProxyConnection@778350106 wrapping conn1] to 
manual commit
inner.isNewTransaction()=true
내부 트랜잭션 롤백
Initiating transaction rollback
Rolling back JDBC transaction on Connection [HikariProxyConnection@778350106 
wrapping conn1]
Releasing JDBC Connection [HikariProxyConnection@778350106 wrapping conn1] after 
transaction
Resuming suspended transaction after completion of inner transaction
외부 트랜잭션 커밋
Initiating transaction commit
Committing JDBC transaction on Connection [HikariProxyConnection@1064414847 
wrapping conn0]
Releasing JDBC Connection [HikariProxyConnection@1064414847 wrapping conn0] 
after transaction

외부 트랜잭션 시작

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

내부 트랜잭션 시작

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

내부 트랜잭션 롤백

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

외부 트랜잭션 커밋

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

요청 흐름 - 외부 트랜잭션

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

요청 흐름 - 내부 트랜잭션

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

응답 흐름 - REQUIRES_NEW

응답 흐름 - 내부 트랜잭션

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

응답 흐름 - 외부 트랜잭션

• 4. 외부 트랜잭션에 커밋 요청
• 5. 외부 트랜잭션은 신규 트랜잭션이기 떄문에 물리 트랜잭션을 커밋
• 6. 이때 rollbackOnly 설정을 체크, rollbackOnly 설정이 없음 커밋함
• 7. 본인이 만든 con1 커넥션을 통해 물리 트랜잭션 커밋, 트랜잭션이 종료되고, con1은 종료되거나, 커넥션 풀에 반납

정리

• REQUIRES_NEW 옵션을 사용하면 물리 트랜잭션이 명확하게 분리
• REQUIRES_NEW를 사용하면 DB 커넥션이 동시에 2개 사용된다는 점 주의

스프링 트랜잭션 전파8 - 다양한 전파 옵션

• 전파 옵션에 별도의 설정 안 하면 REQUIRED 기본으로 사용됨
• 실무는 대부분 REQUIRED 옵션 사용
• 가끔 REQUIRES_NEW 사용, 나머지는 거의 사용 안 함

REQUIRED

• 가장 많이 사용하는 기본 설정
• 기존 트랜잭션이 없으면 생성하고, 있으면 참여
• 트랜잭션이 필수라는 의미로 이해(필수이기 떄문에 없으면 만들고, 있으면 참여)
• 기존 트랜잭션 없음: 새로운 트랜잭션을 생성
• 기존 트랜잭션 있음: 기존 트랜잭션에 참여

REQUIRES_NEW

• 항상 새로운 트랜잭션 생성
• 기존 트랜잭션 없음: 새로운 트랜잭션을 생성
• 기존 트랜잭션 있음: 새로운 트랜잭션을 생성

NOT_SUPPORT

• 트랜잭션을 지원하지 않음
• 기존 트랜잭션 없음: 트랜잭션 없이 진행
• 기존 트랜잭션 있음: 트랜잭션 없이 진행 (기존 트랜잭션은 보류)

MANDATORY

• 의무사항, 트랜잭션이 반드시 있어야 함, 기존 트랜잭션 없음 예외 발생
• 기존 트랜잭션 없음: IllegalTransactionStateException 예외 발생
• 기존 트랜잭션 있음: 기존 트랜잭션에 참여

NEVER

• 트랜잭션을 사용하지 않음, 기존 트랜잭션이 있음 예외 발생, 기존 트랜잭션도 허용하지 않는 강한 부정의 의미
• 기존 트랜잭션 없음: 트랜잭션 없이 진행
• 기존 트랜잭션 있음: IllegalTransactionStateException 예외 발생

NESTED

• 기존 트랜잭션 없음: 새로운 트랜잭션을 생성
• 기존 트랜잭션 있음: 중첩 트랜잭션을 만듬
• 중첩 트랜잭션은 외부 트랜잭션의 영향을 받음, 중첩 트랜잭션은 외부에 영향 안 줌
• 중첩 트랜잭션이 롤백 되어도 외부 트랜잭션은 커밋 가능
• 외부 트랜잭션이 롤백 되면 중첩 트랜잭션도 함꼐 롤백

참고

• JDBC savepoint 기능 사용, DB 드라이버에 해당 기능을 지원하는지 확인 필요
• 중첩 트랜잭션은 JPA에서 사용할 수 없음

트랜잭션 전파와 옵션

• isolation, timeout, readOnly는 트랜잭션이 처음 시작될 떄만 적용, 트랜잭션에 참여하는 경우 적용 되지 않음
• EX) REQUIRED를 통한 트랜잭션 시작, REQUIRES_NEW를 통한 트랜잭션 시작 시점에만 적용