Ch09. 스프링 트랜잭션 이해 - 트랜잭션 AOP 주의 사항(프록시 내부 호출)

문제

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

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

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

따라서 트랜잭션을 적용하려면 항상 프록시를 통해서 대상 객체(Target)를 호출해야 한다.

이렇게 해야 프록시에서 먼저 트랜잭션을 적용하고, 이후에 대상 객체를 호출하게 된다.

만약 프록시를 거치지 않고 대상 객체를 직접 호출하게 되면 AOP가 적용되지 않고, 트랜잭션도 적용되지 않는다

프록시의 메소드를 호출해야 트랜젝션이 적용이 된다.

AOP를 적용하면 스프링은 대상 객체 대신에 프록시를 스프링 빈으로 등록한다.

따라서 스프링은 의존관계 주입시에 항상 실제 객체 대신에 프록시 객체를 주입한다. 프록시 객체가 주입되기 때문에 대상 객체를 직접 호출하는 문제는 일반적으로 발생하지 않는다.

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

InternalCallV1Test

@Slf4j
@SpringBootTest
public class InternalCallV1Test {

    @Autowired
    CallService callService;

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

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

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

    @TestConfiguration
    static class InternalCallV1TestConfig{
        @Bean
        public 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();
        }

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

}

• external()은 트랜잭션이 없다.
• internal()은 @Transactional을 통해 트랜잭션을 적용한다.
• @Transactional 이 하나라도 있으면 트랜잭션 프록시 객체가 만들어진다. 그리고 callService 빈을 주입 받으면 트랜잭션 프록시 객체가 대신 주입된다

internalCall()

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

internalCall()

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

externalCall() 

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

• 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.internal() 이 되는데, 여기서 this는 자기 자신을 가리키므로, 실제 대상 객체( target )의 인스턴스를 뜻한다.

결과적으로 이러한 내부 호출은 프록시를 거치지 않는다. 따라서 트랜잭션을 적용할 수 없다.

결과적으로 target에 있는 internal()을 직접 호출하게 된 것이다.

 

해결 방법 : 클래스 컴파일 시, 코드에 byte코드에 transaction 코드를 직접 주입해 주는 방식도 존재하지만, 너무 복잡하여 실무에서도 자주 사용되지 않는다.

--> 내부 호출을 피하기 위해 internal() 메서드를 별도의 클래스로 분리하여 해결할 수 있다.

별도의 클래스로 분리

@Slf4j
@SpringBootTest
public class InternalCallV2Test {

    @Autowired
    CallService callService;

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

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

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

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

외부 메소드로 분리 후 동작 과정

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

public 메서드만 트랜잭션 적용

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

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