spring/스프링 DB 2편

8. 스프링 트랜잭션 이해(2) 주의사항, 프록시, 초기화 시점

sh1mj1 2023. 2. 23. 17:23
이 글은 배민 기술이사 김영한 이사님의 인프런 강의 "스프링 DB 2편 - 데이터 접근 활용 기술" 을 기반으로 작성되었습니다. 문제 시 삭제 조치하겠습니다.

 

아래와 같은 순서로 공부를 진행합니다.

 

 

  • 트랜잭션 AOP 주의 사항 - 프록시 내부 호출
  • 트랜잭션 AOP 주의 사항 - 초기화 시점

 

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

프록시 내부 호출

@Transactional을 사용하면 스프링의 트랜잭션 AOP가 적용됩니다. 트랜잭션 AOP는 기본적으로 프록시 방식의 AOP를 사용합니다.

 

@Transactional을 적용하면 프록시 객체가 요청을 먼저 받아서 트랜잭션을 처리하고 실제 객체를 호출합니다. 따라서 트랜잭션을 적용하려면 항상 프록시를 통해서 대상 객체(Target)을 호출해야 합니다.

 

이렇게 해야 프록시에서 먼저 트랜잭션을 적용하고, 이후에 대상 객체를 호출합니다. 만약 프록시를 거치지 않고 대상 객체를 직접 호출하게 되면 AOP가 적용되지 않고, 트랜잭션도 적용되지 않습니다.

 

https://user-images.githubusercontent.com/52024566/204537728-962ff274-5c19-4e4b-b401-dd83468f35bc.png

AOP를 적용하면 스프링은 대상 객체 대신에 프록시를 스프링 빈으로 등록합니다. 따라서 스프링은 의존관계 주입 시에 항상 실제 객체 대신에 프록시 객체를 주입합니다.

프록시 객체가 주입되기 때문에 대상 객체를 직접 호출하는 문제는 일반적으로 발생하지 않습니다.

 

하지만 대상 객체의 내부에서 메서드 호출이 발생하면 프록시를 거치지 않고 대상 객체를 직접 호출하는 문제가 발생합니다. 이렇게 되면 @Transactional이 있어도 트랜잭션이 적용되지 않습니다. 이 문제는 실무에서도 반드시 한번은 만나서 고생하는 문제입니다.

 

InternalCallV1Test

@Slf4j
@SpringBootTest
public class InternalCallV1Test {

    @Autowired
    CallService callService;

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

    @Test
    void internalCall() {
        callService.internal();
    }

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

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

    @Slf4j
    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);
        }
    }
}

 

CallService

  • external()은 트랜잭션이 없음
  • internal()은 @Transactional을 통해 트랜잭션을 적용

 

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

 

다음 코드를 실행해봅시다.

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

여기서는 테스트에서 callService 를 주입 받는데, 해당 클래스를 출력해보면 뒤에 CGLIB…이 붙은 것을 확인할 수 있습니다. 원본 객체 대신에 트랜잭션을 처리하는 프록시 객체를 주입 받은 것이지요

 

callService class=class hello...
        InternalCallV1Test$CallService$$EnhancerBySpringCGLIB$$4ec3f332

 

internalCall() 실행

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

 

internal()

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

https://user-images.githubusercontent.com/52024566/204537734-606ed8e9-700b-403b-b51c-99f6a08179e5.png

 

  1. 클라이언트인 테스트 코드는 callService.internal()을 호출합니다.
    여기서 callService는 트랜잭션 프록시입니다.
  2. callService의 트랜잭션 프록시가 호출됩니다.
  3. internal() 메서드에 @Transactional이 붙어 있으므로 트랜잭션 프록시는 트랜잭션을 적용합니다.
  4. 트랜잭션 적용 후 실제 callService 객체 인스턴스의 internal()을 호출합니다.
    실제 callService가 처리를 완료하면 응답이 트랜잭션 프록시로 돌아오고, 트랜잭션 프록시는 트랜잭션을 완료합니다.

 

실행 로그 - internalCall()

TransactionInterceptor : Getting transaction for
[..CallService.internal]
..rnalCallV1Test$CallService : call internal
..rnalCallV1Test$CallService : tx active=true
TransactionInterceptor : Completing transaction for
[..CallService.internal]

TransactionInterceptor가 남긴 로그를 통해 트랜잭션 프록시가 트랜잭션을 적용한 것을 확인할 수 있습니다.

CallService가 남긴 tx active=true 로그를 통해 트랜잭션이 적용되어 있음을 확인할 수 있습니다.

 

 

externalCall() 실행

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

 

external()

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

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

external()은 @Transactional 애노테이션이 없습니다. 따라서 트랜잭션 없이 시작합니다.

그런데 내부에서 @Transactional이 있는 internal()을 호출하는 것을 확인할 수 있습니다.

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

 

실행 로그 - externalCall()

CallService : call external
CallService : tx active=false
CallService : call internal
CallService : tx active=false

 

실행 로그를 보면 트랜잭션 관련 코드가 전혀 보이지 않습니다. 프록시가 아닌 실제 callService에서 남긴 로그만 확인됩니다. 추가로 internal() 내부에서 호출한 tx active=false 로그를 통해 확실히 트랜잭션이 수행되지 않은 것을 확인할 수 있습니다.

기대와 다르게 internal()에서 트랜잭션이 전혀 적용되지 않았습니다.

 

그렇다면 문제가 발생하는 원인은 무엇일까요? 아래 그림으로 찬찬히 살펴봅시다.

 

프록시와 내부 호출

https://user-images.githubusercontent.com/52024566/204537738-21b97be9-e6f3-4d51-8d9a-19976be6f100.png

 

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

 

문제 원인

자바 언어에서 메서드 앞에 별도의 참조가 없으면 this라는 뜻으로 자기 자신의 인스턴스를 가리킵니다. 결과적으로 자기 자신의 내부 메서드를 호출하는 this.internal()이 되는데, 여기서 this는 자기 자신을 가리키므로, 실제 대상 객체(target)의 인스턴스를 의미합니다.

 

결과적으로 이러한 내부 호출은 프록시를 거치지 않습니다. 따라서 트랜잭션을 적용할 수 없습니다. 결과적으로 target 에 있는 internal()을 직접 호출합니다.

 

프록시 방식의 AOP 한계

@Transactional를 사용하는 트랜잭션 AOP는 프록시를 사용합니다. 프록시를 사용하면 메서드 내부 호출에 프록시를 적용할 수 없습니다.

그렇다면 이 문제를 해결할 수 있는 방법이 있을까요?

가장 단순한 방법은 내부 호출을 피하기 위해 internal() 메서드를 별도의 클래스로 분리하는 것입니다.

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

 

InternalCallV2Test

@SpringBootTest
public class InternalCallV2Test {

    @Autowired
    CallService callService;

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

    @TestConfiguration
    static class InternalCallV2Config {
        @Bean
        CallService helloService() {
            return new CallService(innerService());
        }

        @Bean
        InternalService innerService() {
            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);
        }
    }

    @Slf4j
    static class InternalService {

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

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

InternalService 클래스를 만들고 internal() 메서드를 여기로 옮겼습니다.

이렇게 메서드 내부 호출을 외부 호출로 변경하였습니다.

 

CallService에는 트랜잭션 관련 코드가 전혀 없으므로 트랜잭션 프록시가 적용되지 않습니다.

그리고 InternalService에는 트랜잭션 관련 코드가 있으므로 트랜잭션 프록시가 적용됩니다.

 

실제 호출되는 흐름

https://user-images.githubusercontent.com/52024566/204815358-2c85bfa5-4344-4bc3-800d-ec7d248f6867.png

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

 

실행 로그 - externalCallV2()

#external()
..InternalCallV2Test$CallService : call external
..InternalCallV2Test$CallService : tx active=false

#internal()
TransactionInterceptor : Getting transaction for
[..InternalService.internal]
..rnalCallV2Test$InternalService : call internal
..rnalCallV2Test$InternalService : tx active=true
TransactionInterceptor : Completing transaction for
[..InternalService.internal]

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로 변경해보면 적용되지 않는 것을 확인할 수 있음
참고로 public이 아닌곳에 @Transactional이 붙어 있으면 예외가 발생하지는 않고, 트랜잭션 적용만 무시됩니다.

 

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

스프링 초기화 시점에는 트랜잭션 AOP가 적용되지 않을 수 있습니다.

@SpringBootTest
public class InitTxTest {

    @Autowired
    Hello hello;

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

    @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);
        }

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

 

테스트 실행

초기화 코드(예: @PostConstruct)와 @Transactional을 함께 사용하면 트랜잭션이 적용되지 않습니다.

(@PostConstruct는 의존성 주입이 이루어진 후 초기화를 수행하는 메서드이다. @PostConstruct가 붙은 메서드는 클래스가 service를 수행하기 전에 발생한다. 이 메서드는 다른 리소스에서 호출되지 않는다해도 수행된다. )

 

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

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

 

initV1() 관련 로그

Hello init @PostConstruct tx active=false

 

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

@EventListener(value = ApplicationReadyEvent.class)
@Transactional
public void init2() {
    log.info("Hello init ApplicationReadyEvent");
}

이 이벤트는 트랜잭션 AOP를 포함한 스프링 컨테이너가 완전히 생성되고 난 다음에 이벤트가 붙은 메서드를 호출합니다. 따라서 init2()는 트랜잭션이 적용된 것을 확인할 수 있음

 

init2() ApplicationReadyEvent 이벤트가 호출하는 로그

TransactionInterceptor : Getting transaction for [Hello.init2]
..ngtx.apply.InitTxTest$Hello 
        : Hello init ApplicationReadyEvent tx active=true
TransactionInterceptor : Completing transaction for [Hello.init2]

'spring > 스프링 DB 2편' 카테고리의 다른 글

9. 스프링 트랜잭션 전파 - 기본  (0) 2023.02.24
8. 스프링 트랜잭션 이해(3)  (0) 2023.02.23
8. 스프링 트랜잭션 이해(1) - 소개, 적용  (0) 2023.02.23
7. 데이터 접근 기술 - 활용 방안 (JPA, JdbcTemplate, MyBatis 조합)  (0) 2023.02.23
6. 데이터 접근 기술 - Querydsl  (0) 2023.02.23

'spring/스프링 DB 2편'의 다른글

  • 현재글8. 스프링 트랜잭션 이해(2) 주의사항, 프록시, 초기화 시점

관련글

티스토리툴바