[Spring] 프록시 내부 호출 문제점

@Transactional을 적용하면 프록시 객체가 요청을 먼저 받아서 트랜잭션을 처리하고, 실제 객체를 호출해준다. 때문에 트랜잭션을 적용하려면 항상 프록시를 통해서 대상 객체(Target)을 호출해야 한다. 이렇게 해야 프록시에서 먼저 트랜잭션을 적용하고, 이후에 대상 객체를 호출하게 된다.
만약 프록시를 거치지 않고 대상 객체를 직접 호출하게 되면 AOP가 적용되지 않고, 트랜잭션도 적용되지 않는다.

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

아래 예제를 보면서 문제점을 파악해보자!

Test Code

@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 InternalCallV1TestConfig {

    @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이 하나라도 있는 경우에는 트랜잭션 프록시 객체가 만들어지고, callService 빈을 주입 받으면 트랜잭션 프록시 객체가 주입된다.

CallServiec가 정말 프록시 객체인지 확인해보자.

CallServiec가 프록시 객체 확인 결과

테스트에서 callService를 주입 받아, 출력해보니 뒤에 CGLIB...이 붙은 것을 확인할 수 있다.
원본 객체 대신에 트랜잭션을 처리하는 프록시 객체를 주입 받은 것이다.

이번에는 트랜잭션이 적용된 internal()를 실행해보자.

internal() 메서드 트랜잭션 적용 여부 확인 결과

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

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

그렇다면 트랜잭션을 적용하지 않은 external()은 내부에서 트랜잭션이 적용된 internal()을 호출하고 있다. 이 경우에는 어떤 결과가 나올지 실행해보자.

external() 메서드에서 호출하는 internal() 메서드 트랜잭션 적용 여부 확인 결과

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

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

external()은 자기 자신의 내부 메서드를 호출하는 this.internal()이 되는데, 여기서 this는 자기 자신을 가리키므로, 실제 대상 객체(target)의 인스턴스를 뜻한다. 내부 호출은 프록시를 거치지 않기 때문에 트랜잭션을 적용할 수 없다. 결과적으로 target에 있는 internal()을 직접 호출하게 된 것이다.

@Transactional를 사용하는 트랜잭션 AOP는 프록시를 사용하는데, 프록시를 사용하면 메서드 내부 호출에 프록시를 적용할 수 없다. 이 문제를 해결하는 가장 단순한 방법으로는 내부 호출을 피하기 위해 별도의 클래스로 분리하는 것이다.

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

Test Code V2

@Slf4j
@SpringBootTest
public class InternalCallV2Test {

  @Autowired
  CallService callService;

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

  @Test
  void externalCallV2() {
    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);
    }

  }

  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에는 트랜잭션 관련 코드가 있으므로 트랜잭션 프록시가 적용된다.

externalV2() 메서드에서 호출하는 internal() 메서드 트랜잭션 적용 여부 확인 결과

TransactionInterceptor 로그가 보이며, InternalService의 tx active=true 로그를 통해 internal() 호출에서 트랜잭션이 적용된 것을 확인할 수 있다

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

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