[스프링 DB 2편] #9. 스프링 트랜잭션 이해(2)

[Pracrobo]

트랜잭션 AOP 주의사항 - 프록시 내부 호출 1

실무에서 많이 만나는 주제이자 많은 개발자들이 이해하지 못해서 고통받는 주제이다.

여기서는 트랜잭션 AOP의 관점에서 설명한다.

@Transactional을 사용하면 스프링의 트랜잭션 AOP가 적용된다.

트랜잭션 AOP는 기본적으로 프록시 AOP를 사용한다.

@Transactional 을 적용하면 프록시 객체가 요청을 먼저 받아서 트랜잭션을 처리하고 실제 객체를 호출해준다.

따라서 트랜잭션을 적용하려면 항상 프록시를 통해서 대상 객체 (Target)을 호출해야 한다. 이렇게 해야 프록시에서 먼저 트랜잭션을 적용하고 이후에 대상 객체를 호출하게 된다. 만약 프록시를 거치지 않고 대상 객체를 직접 호출하게 되면 AOP가 적용되지 않고 트랜잭션도 적용되지 않는다.

(@Autowired 하면 항상 proxy 호출)(내부에서 호출하면 프록시를 거치지 않고 직접 호출하는 문제가 발생)

AOP를 적용하면 스프링은 대상 객체 대신 프록시를 스프링 빈으로 등록한다. 따라서 스프링은 의존관계 주입시에 항상 실제 객체 대신에 프록시 객체를 주입한다. 프록시 객체가 주입되기 때문에 대상 객체를 직접 호출하는 문제는 일반적으로 발생하지 않는다. 하지만 **“대상 객체의 내부에서 메서드 호출이 발생하면 프록시를 거치지 않고 대상 객체를 직접 호출하는 문제가 발생”**한다.

이렇게 되면 @transactional이 있어도 트랜잭션이 적용되지 않는다. 실무에서 반드시 한번은 만나 고생하는 문제기 때문에 꼭 이해하고 넘어가자

전체코드 test > InternalCallV1Test.java

package hello.springtx.apply;

@Slf4j
@SpringBootTest
public class InternalCallV1Test {

    @Autowired CallService callService; //@Transactional 있어서 Proxy 주입됨
    @Test
    void printProxy() {
        log.info("callService class= {}", callService.getClass()); //CGLIB 출력됨
    }

    @Test
    void internalCall() {
        callService.internal(); //internal() 메서드 출력 
    }

    @Test
    void external() {
        callService.external();
    }

    @TestConfiguration
    static class InternalCallV1TestConfig{
        @Bean
        CallService callService() {
            return new CallService();
        }
    }
    
    static class CallService {
        // 트랜잭션 없는 구간
        public void external() {
            log.info("call external")  
            printTxInfo(); 
            internal();
        }

        // 트랜잭션 있는 구간
        @Transactional
        public void internal() {
            log.info("call internal")
            printTxInfo();
        }

        private void printTxInfo() {
            boolean txActive = TransactionSynchronizationManager.isActualTransactionActive();
            log.info("tx active = {}", txActive);
           // boolean readOnly = TransactionSynchronizationManager.isCurrentTransactionReadOnly();
           // log.info("tx readOnly = {}", readOnly);
        }
    }
}

“CallService”

• external() 은 트랜잭션이 없다.
• internal()은 @transactional을 통해 트랜잭션을 적용한다.

@transactional이 하나라도 있으면 트랜잭션 프록시 객체가 만들어진다. 그리고 callService 빈을 주입받으면 트랜잭션 프록시 객체가 대신 주입한다.

@Test
void printProxy() {
	log.info("call Service class = {}", callService.getClass());
}	

여기서는 테스트에서 callService 를 주입받는데 해당 클래스를 출력해보면 CGLIB가 출력된다. 원본 객체 대신에 트랜잭션을 처리하는 프록시 객체를 주입 받은 것이다.

“InternalCall()” 실행

internalCall()은 트랜잭션이 있는 코드인 internal() 을 호출한다.

@Transactional
public void internal() {
	log.info("call internal");
	printTxInfo();
}

1. 클라이언트인 테스트 코드는 callService.internal()을 호출한다. 여기서 callService는 트랜잭션 프록시이다.
2. callService 의 트랜잭션 프록시가 호출된다.
3. internal() 메서드에 @transactional이 붙어있으므로 트랜잭션 프록시는 트랜잭션을 적용한다.
4. 트랜잭션 적용 후 실제 callService 객체 인스턴스의 internal()을 호출한다.

• 실제 callService가 처리를 완료하면 응답이 트랜잭션 프록시로 돌아오고 트랜잭션 프록시는 트랜잭션을 완료한다.

• TransactionInterceptor가 남긴 로그를 통해 트랜잭션 프록시가 트랜잭션을 적용한 것을 확인할 수 있다.
• CallService가 남긴 tx active =true 로그를 통해 트랜잭션이 적용되어 있음을 확인할 수 있다.

externalCall() 실행

• externalCall()은 트랜잭션이 없는 없는 코드인 external()을 호출한다.

    public void external() {
            log.info("call external")  
            printTxInfo(); 
            internal();
        }

        // 트랜잭션 있는 구간
        @Transactional
        public void internal() {
            log.info("call internal")
            printTxInfo();
        }

        private void printTxInfo() {
            boolean txActive = TransactionSynchronizationManager.isActualTransactionActive();
            log.info("tx active = {}", txActive);
           // boolean readOnly = TransactionSynchronizationManager.isCurrentTransactionReadOnly();
           // log.info("tx readOnly = {}", readOnly);
        }
    }

external()는 @transactional 애노테이션이 없다. 따라서 트랜잭션 없이 시작한다. 그런데 내부에서 @transactional이 있는 internal()을 호출하는 것을 확인할 수 있다.

이 경우 external() 은 트랜잭션이 없지만 internal()에서는 트랜잭션이 적용되는 것처럼 보인다.

실행로그를 보면 트랜잭션 관련 코드가 전혀 보이지 않는다. 프록시가 아닌 실제 callService 에서 남긴 로그만 확인된다.

추가로 internal() 내부에서 호출한 tx active = false 로그를 통해 확실히 트랜잭션이 수행되지않은 것을 확인할 수 있다.

우리의 기대와 다르게 internal()에서 트랜잭션이 전혀 적용되지 않았다 이유가 뭘까?

“프록시와 내부 호출”

실제 호출되는 흐름을 분석해보자

1. 클라이언트인 테스트 코드는 callService.external() 을 호출한다. 여기서 callService는 트랜잭션 프록시이다.
2. callService의 트랜잭션 프록시가 호출된다
3. external() 메서드에는 @transactional이 없다. 따라서 트랜잭션 프록시는 트랜잭션을 적용하지 않는다.
4. 트랜잭션 적용하지 않고 실제 callService 객체 인스턴스의 external()을 호출한다.
5. external()은 내부에서 internal() 메서드를 호출한다. 그런데 여기서 문제가 발생한다. (프록시를 안거치고)

“문제 원인”

자바 언어에서 메서드 앞에 별도의 참조가 없으면 this 라는 뜻으로 자기자신의 인스턴스를 가리킨다. (this 생략됨)

결과적으로 자기 자신의 내부 메서드를 호출하는 this.internal() 이 되는데 여기서 this 는 자기자신을 가리키므로 실제 대상 객체 target의 인스턴스를 뜻한다.

결과적으로 이러한 내부호출은 프록시를 거치지 않는다.

따라서 트랜잭션을적용할 수 없다. 결과적으로 target 있는 internal()을 직접 호출하게 된 것이다.

“프록시 방식의 AOP 한계”

@transactional 을 사용하는 트랜잭션 aOP는 프록시를 사용한다. 프록시를 사용하면 메서드 내부 호출에 프록시를 적용할 수 없다.

그렇다면 이 문제를 어떻게 해결할까?
가장 단순한 방법은 내부 호출을 피하기 위해 internal()메서드를 별도의 클래스로 분리하는 것이다.

트랜잭션 AOP 주의사항 - 프록시 내부 호출2

메서드 내부 호출때문에 트랜잭션 프록시가 적용되지 않는 문제를 해결하기 위해 ‘internal()’ 메서드를 별도의 클래스로 분리하자

package hello.springtx.apply;

@Slf4j
@SpringBootTest
public class InternalCallV2Test {

    @Autowired CallService callService; //@Transactional 있어서 Proxy 주입됨
    @Test
    void printProxy() {
        log.info("callService class= {}", callService.getClass()); //CGLIB 출력됨
    }

    @Test
    void externalV2() {
        callService.external();
    }

    @TestConfiguration
    static class InternalCallV1TestConfig{
      
        @Bean
        CallService callService() {
            return new CallService(internalService());
        }

        @Bean
        InternalService internalService() {
            return new InternalService();
        }
    }
    
    @Slf4j
    @RequiredArgsConstructor // 추가
    static class CallService {

        private final InternalService internalService; // 추가 
    
        public void external() {
            log.info("call external")  
            printTxInfo(); 
            internalService.internal(); //내부 호출에서 외부 호출로 변경
        }

        private void printTxInfo() {
            boolean txActive = TransactionSynchronizationManager.isActualTransactionActive();
            log.info("tx active = {}", txActive);
           // boolean readOnly = TransactionSynchronizationManager.isCurrentTransactionReadOnly();
           // log.info("tx readOnly = {}", readOnly);
        }
    }
    // 클래스로 분리해서 
    // 외부 호출과 내부 호출로 나눈다.
    static class InternalService {
        
        // 트랜잭션 있는 구간
        @Transactional
        public void internal() {
            log.info("call internal")
            printTxInfo();
        }

        private void printTxInfo() {
            boolean txActive = TransactionSynchronizationManager.isActualTransactionActive();
            log.info("tx active = {}", txActive);
           // boolean readOnly = TransactionSynchronizationManager.isCurrentTransactionReadOnly();
           // log.info("tx readOnly = {}", readOnly);
        }
    }
}

• InternalService 클래스를 만들고 internal() 메서드를 옮겼다
• 이렇게 메서드 내부 호출을 외부 호출로 변경했다.
• CallService에는 트랜잭션 관련 코드가 전혀 없으므로 트랜잭션 프록시가 적용되지 않는다.
• InternalService 에는 트랜잭션 관련 코드가 있으므로 트랜잭션 프록시가 적용된다.

실제 호출되는 흐름을 분석해보자

1. 클라이언트인 테스트 코드는 callService.external()을 호출한다.
2. callService 는 실제 callService 객체 인스턴스이다.
3. callService는 주입 받은 internalService.internal() 을 호출한다.
4. internalService는 트랜잭션 프록시이다. internal() 메서드에 @Transactional이 붙어있으므로 트랜잭션 프록시는 트랜잭션을 적용한다.
5. 트랜잭션 적용 후에 실제 internalService 객체인스턴스의 internal()을 호출한다.

“실행로그 - externalCallV2()”

• Transactioninterceptor 를 통해 트랜잭션이 적용되는 것을 확인할 수 있다.
• InternalService 의 tx active=true 로그를 통해 internal() 호출에서 트랜잭션이 적용된 것을 확인할 수 있다.

여러가지 다른 방안도 있지만 실무에서는 이렇게 별도의 클래스로 분리하는 방법을 주로 사용한다.

public 메서드만 트랜잭션 적용

스프링의 트랜잭션 AOP 기능은 ‘public’메서드에만 트랜잭션을 적용하도록 기본 설정이 되어 있다. 그래서 ‘protected’, ‘private’ , ‘package-visible’에는 트랜잭션이 적용되지 않는다. 생각해보면 ‘protected’, ‘package-visible’도 외부에서 호출이 가능하다. 따라서 부분은 앞서 설명한 프록시의 내부 호출과는 무관하고 스프링이 막아둔 것이다.

스프링이 public 에만 트랜잭션을 적용하는 이유는 다음과 같다.

@Transactional //보통 클래스 레벨에 트랜잭션을 건다
public class Hello {
	public method1();
	method2();
	protected method3();
	private method4();
}

• 이렇게 클래스 레벨에 트랜잭션을 적용하면 모든 메서드에 트랜잭션이 걸릴 수 있다. 그러면 트랜잭션을 의도하지 않는 곳까지 트랜잭션이 과도하게 적용된다. 트랜잭션은 주로 비즈니스 로직의 시작점에 걸기 때문에 대부분 외부에 열어준 곳을 시작점으로 사용한다. 이런 이유로 ‘public’ 메서드에만 트랜잭션을 적용하도록 설정되어 있다.
• 앞서 실행했던 코드를 package-visible 로 변경해보면 적용되지 않는 것을 확인할 수 있다.

트랜잭션 AOP 주의 사항 - 초기화 시점

• spring 초기화 시점에는 트랜잭션 AOP 가 적용되지 않을 수 있다.
• @PostConstruct

package hello.springtx.apply;

@SpringBootTest
public class InitTxTest {

    @Autowired Hello hello;

    @Test
    void go() {
        //초기화 코드는 스프링이 초기화 시점에 호출한다.
        //hello.initV1();
    }

    @TestConfiguration
    static class InitTxTestConfig {
        @Bean
        Hello hello () {
            return new Hello();
        }
    }

    @Slf4j
    static class Hello {
        @PostConstruct
        @Transactional
        public void initV1 () {
                boolean isActive = TransactionSynchronizationManager.isActualTransactionActive();
                log.info("Hello init @PostConstruct tx active={}", isActive)
            }

        public void initV2 () {
            
        }
    }
}

초기화 코드(ex. @PostConstruct) 와 @Transatction 을 함께 사용하면 트랜잭션이 적용되지 않는다.

@PostConstruct
@Transactional
public void initV1() {
	log.info("Hello init @PostConstruct");
}

왜냐하면 초기화 코드가 먼저 호출되고(PostConstruct) 그다음에 트랜잭션 AOP 가 적용되기 때문이다.(Transaction) 따라서 초기화 시점에는 해당 메서드에서 트랜잭션을 획득할 수 없다.

“initV1() 관련 로그”

Hello init @PostConstruct tx active=false

가장 확실한 대안은 ApplicationReadyEvent 이벤트를 사용하는 것이다.

	
    **@EventListener(ApplicationReadyEvent.class)
    @Transactional**
    public void initV2 () {
        boolean isActive = TransactionSynchronizationManager.isActualTransactionActive();
        log.info("Hello init ApplicationReadyEvent tx active={}", isActive)
    }
    ****이 이벤트는 트랜잭션 AOP를 포함한 스프링이 컨테이너가 완전히 생성되고 난 다음에 이벤트가 붙은 메서드를 호출해준다. 따라서 init2() 는 트랜잭션이 적용된 것을 확인할 수 있다.

“init2()” ApplicatonReadyEvent 이벤트가 호출하는 코드

트랜잭션 옵션 소개

스프링 트랜잭션은 다양한 옵션을 제공한다. 이번 시간에는 각각의 옵션들을 간략하게 소개하겠다.

“@transactional - 코드, 설명 순서에 따라 약간 수정했음”

public @interface Transactional {
	String value() default "";
	String transactionManager() default "";
	
	Class<? extends Throwable>[] rollbackFor() default {};
	Class<? extends Throwable>[] noRollbackFor() default {};

	Propagation propagation() default Propagation.REQUIRED;
	Isolation isolation() default Isolation.DEFAULT;
	int timeout() default TransactionDefinition.TIMEOUT_DEFAULT;
	boolean readOnly() default false;
	String[] label() default {};
}		

---

“value, transactionManager”

트랜잭션을 사용하려면 먼저 스프링 빈에 등록된 어떤 트랜잭션 매니저를 사용할지 알아야 한다. 생각해보면 코드로 직접 트랜잭션을 사용할때 분명 트랜잭션 매니저를 주입 받아서 사용했다. @transactional에서도 트랜잭션 프록시가 사용할 트랜잭션 매니저를 지정해주어야 한다.

사용할 트랜잭션 매니저를 지정할때는 value, transactionManager 둘 중 하나에 트랜잭션 매니저의 스프링 빈의 이름을 적어주면 된다.

이 값을 생략하면 기본으로 등록된 트랜잭션 매니저를 사용하기 때문에 대부분 생략한다. 그런데 사용하는 트랜잭션 매니저가 둘 이상이라면 다음과 같이 트랜잭션 매니저의 이름을 지정해서 구분하면 된다.

public class TxService {
	@Transactional("memberTxManager")
	public void member() {..}
	
	@Transactional("orderTxManager")
	public void order() {..}
}

참고로 애노테이션에서 속성이 하나인 경우 위 예처럼 value 는 생략하고 값을 바로 넣을 수 있다.

rollbackFor

예외 발생시 스프링 트랜잭션의 기본 정책은 다음과 같다.

• 언체크 예외인 RuntimeException, Error 와 그 하위 예외가 발생하면 롤백한다.
• 체크 예외인 Exception 과 그 하위 예외들은 커밋한다.

이 옵션을 사용하면 기본 정책에 추가로 어떤 예외가 발생할때 롤백할지 지정할 수 있다.

@Transactional(rollbackFor = Exception.class)

예를 들어서 이렇게 지정하면 체크 예외인 Exception 이 발생해도 롤백하게 된다. (하위 예외들도 대상에 포함된다.)

‘rollbackForClassName’ 도 있는데 ‘rollbackFor’ 는 예외클래스를 직접 지정하고 rollbackForClassName 는 예외 이름을 문자로 넣으면 된다.

noRollbackFor

앞서 설명한 rollbackFor 와 반대이다. 기본 정책에 추가로 어떤 예외가 발생했을 때 롤백하면 안되는지 지정할 수 있다.

예외 이름을 문자로 넣을 수 있는 noRollbackForClassName 도 있다.

롤백 관련 옵션에 대한 더 자세한 내용은 뒤에서 설명.

propagation

트랜잭션 전파에 대한 옵션이다.

isolation

트랜잭션 격리 수준을 지정할 수 있따. 기본 값은 데이터 베이스에서 설정한 트랜잭션 격리 수준을 사용하는 DEFAULT이다. 대부분 데이터베이스에서 설정한 기준을 따른다. 애플리케이션 개발자가 트랜잭션 격리 수준을 직접 지정하는 경우는 드물다.

• DEFAULT : 데이터베이스에서 설정한 격리 수준을 따른다.
• READ_UNCOMMITTED : 커밋되지 않은 읽기
• READ_COMMITTED : 커밋된 읽기
• REPEATABLE_READ : 반복 가능한 읽기
• SERIALIZABLE : 직렬화 가능

timeout

트랜잭션 수행 시간에 대한 타임아웃을 초단위로 지정한다. 기본 값은 트랜잭션 시스템의 타임아웃을 사용한다. 운영환경에 따라 동작하는 경우도 있고 그렇지 않은 경우도 있기 때문에 꼭 확인하고 사용해야 한다.

timeoutString 도 있는데 숫자 대신 문자 값으로 지정할 수 잇따..

label

트랜잭션 애노테이션에 있는 값을 직접 읽어서 어떤 동작을 하고 싶을 때 사용할 수 있다. 일반적으로 사용하지 않는다.

readOnly

트랜잭션은 기본적으로 읽기쓰기가 모두 가능한 트랜잭션이 생성된다.

readOnly = true 옵션을 사용하면 읽기 전용 트랜잭션이 생성된다. 이 경우 등록, 삭제, 수정이 안되고 읽기 기능만 작동한다.

(드라이버나 데이터베이스에 따라 정상 동작하지 않는 경우도 있다.) 그리고 readOnly 옵션을 사용하면 읽기에서 다양한 성능 최적화가 발생할 수 잇따.

readOnly 옵션은 크게 3곳에서 적용된다.

“프레임워크”

• JdbcTemplate 은 읽기 전용 트랜잭션 안에서 변경 기능을 실행하면 예외를 던진다.
• JPA(하이버네이트)는 읽기 전용 트랜잭션의 경우 커밋시점에 플러시(뭐가 변했는지를 파악해서 db에 보내는것)를 호출하지 않는다. 읽기 전용이니 변경에 사용되는 플러시를 호출할 필요가 없다. 추가로 변경이 필요 없으니 변경 감지를 위한 스냅샷 객체도 생성하지 않는다. 이렇게 JPA에서는 다양한 최적화가 발생한다.

“JDBC 드라이버”

• 참고로 여기서 설명하는 내용들은 DB 와 드라이버 버전에 따라서 다르게 동작하기 때문에 사전에 확인이 필요하다.
• 읽기 전용 트랜잭션에서 변경 쿼리가 발생하면 예외를 던진다.
• 읽기, 쓰기(마스터, 슬레이브) 데이터베이스를 구분해서 요청한다. 읽기 전용 트랜잭션의 경우 읽기(슬레이브) 데이터 베이스의 커넥션을 획득해서 사용한다.

“데이터베이스”

• 데이터베이스에 따라 읽기 전용 트랜잭션의 경우 읽기만 하면 되므로 내부에서 성능 최적화가 발생한다.