7 분 소요

 인프런 스프링 DB 2편 - 데이터 접근 활용 기술편을 학습하고 정리한 내용 입니다.

트랜잭션 적용 위치

코드를 통해 @Transactional의 적용 위치에 따른 우선순위를 확인해보자.

스프링에서 우선순위는 항상 더 구체적이고 자세한 것이 높은 우선순위를 가진다.

예를 들어서 메서드와 클래스에 애노테이션을 붙일 수 있다면 더 구체적인 메서드가 더 높은 우선순위를 가진다. 인터페이스와 해당 인터페이스를 구현한 클래스에 애노테이션을 붙일 수 있다면 더 구체적인 클래스가 더 높은 우선순위를 가진다.

TxLevelTest

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

@SpringBootTest  
public class TxLevelTest {  
  
    @Autowired LevelService service;  
  
    @Test  
    void orderTest() {  
        service.write();  
        service.read();  
    }  
  
    @TestConfiguration  
    static class TxLevelTestConfig {  
        @Bean  
        LevelService levelService() {  
            return new LevelService();  
        }    }  
  
    @Slf4j  
    @Transactional(readOnly = true)  
    static class LevelService {  
  
        @Transactional(readOnly = false)  
        public void write() {  
            log.info("call write");  
            printTxInfo();  
        }  
        public void read() {  
            log.info("call read");  
            printTxInfo();  
        }  
        private void printTxInfo() {  
            boolean txActive = TransactionSynchronizationManager.isActualTransactionActive();  
            log.info("tx Active = {}", txActive);  
  
            boolean readOnly = TransactionSynchronizationManager.isCurrentTransactionReadOnly();  
            log.info("tx ReadOnly = {}", readOnly);  
        }    }  
}

스프링의 @Transactional은 다음 두 가지 규칙이 있다.

  1. 우선순위 규칙
  2. 클래스에 적용하면 메서드는 자동 적용

우선순위

LevelService를 보면 클래스에는 @Transactional(readOnly = true), 메서드에는 @Transactional(readOnly = false) 다양하게 옵션이 걸려있다.

  • 클래스보다는 메서드가 더 구체적이므로 메서드에 있는 @Transactional(readOnly = false)옵션을 사용한 트랜잭션이 적용된다.

클래스에 적용하면 메서드는 자동 적용

  • read() : 해당 메서드에 @Transactional이 없다. 이 경우 더 상위인 클래스를 확인한다.
    • 클래스에 @Transactional(readOnly = true)이 적용되어 있다. 따라서 트랜잭션이 적용되고 readOnly = true옵션을 사용하게 된다.
    • 참고로 readOnly=false는 기본 옵션이기 때문에 보통 생략한다

결과 확인

TransactionSynchronizationManager.isCurrentTransactionReadOnly : 현재 트랜잭션에 적용된 readOnly 옵션의 값을 반환한다

  • write()에서는 tx readOnly=false : 읽기 쓰기 트랜잭션이 적용되었다. readOnly가 아니다.
  • read()에서는 tx readOnly=true : 읽기 전용 트랜잭션 옵션인 readOnly가 적용되었다.

인터페이스에 @Transactional 적용

인터페이스에도 @Transactional을 적용할 수 있다. 이 경우 다음 순서로 적용된다. 구체적인 것이 더 높은 우선순위를 가진다고 생각하면 바로 이해가 될 것이다.

  1. 클래스의 메서드 (우선순위가 가장 높다.)
  2. 클래스의 타입
  3. 인터페이스의 메서드
  4. 인터페이스의 타입 (우선순위가 가장 낮다.)

그런데 인터페이스에 @Transactional사용하는 것은 스프링 공식 메뉴얼에서 권장하지 않는 방법이다. AOP를 적용하는 방식에 따라서 인터페이스에 애노테이션을 두면 AOP가 적용이 되지 않는 경우도 있기 때문이다. 가급적 구체 클래스에 @Transactional을 사용하자.

참고
스프링은 5.0에서 많은 부분을 개선해서 인터페이스에 @Transactional을 사용할 수 있도록 개선했다. 하지만 가급적 구체클래스에서 @Transactional을 사용하자.

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

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

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

따라서 트랜잭션을 적용하려면 항상 프록시를 통해서 대상 객체(Target)을 호출해야 한다. 이렇게 해야 프록시에서 먼저 트랜잭션을 적용하고, 이후에 대상 객체를 호출하게 된다.

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

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

하지만 대상 객체의 내부에서 메서드 호출이 발생하면 프록시를 거치지 않고 대상 객체를 직접 호출하는 문제가 발생한다.

이렇게 되면 @Transactional이 있어도 트랜잭션이 적용되지 않는다.

InternalCallV1Test

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

@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  
        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();  
        }  
        private void printTxInfo() {  
            boolean txActive = TransactionSynchronizationManager.isActualTransactionActive();  
            log.info("tx Active = {}", txActive);  
        }    }  
}

CallService

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

@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);  
    }}
  • external()은 트랜잭션이 없다.
  • internal()은 @Transactional을 통해 트랜잭션을 적용한다.

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

1
2
3
4

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

다음 테스트를 실행해보면

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

internalCall() 실행

1
2
3
4

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

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

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

externalCall() 실행

자 이제 문제의 externalCall()을 실행해보자.

1
2
3
4

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

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

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

실행 로그를 보자.

call internal로그가 있는데도 tx Active = false가 나왔다.

기대와 다르게 internal()에서 트랜잭션이 전혀 적용되지 않았다. 왜 이런 문제가 발생하는 것일까?

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

그러니까 한 줄로 요약하면 트랜잭션으로 인해 프록시 객체가 생겼고, external을 실행하려 했는데 트랜잭션 미적용 로직이니깐 실제 인스턴스의 external을 실행했다.

문제 원인

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

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

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

프록시 방식의 AOP 한계

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

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

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

InternalCallV2Test

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

@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  
        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()을 호출한다.

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

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

public 메서드만 트랜잭션 적용

스프링의 트랜잭션 AOP 기능은 public메서드에만 트랜잭션을 적용하도록 기본 설정이 되어있다.

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

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

1
2
3
4
5
6
7

@Transactional 
public class Hello { 
	public method1(); 
	method2(); 
	protected method3(); 
	private method4(); 
}
  • 이렇게 클래스 레벨에 트랜잭션을 적용하면 모든 메서드에 트랜잭션이 걸릴 수 있다. 그러면 트랜잭션을 의도하지 않는 곳 까지 트랜잭션이 과도하게 적용된다. 트랜잭션은 주로 비즈니스 로직의 시작점에 걸기 때문에 대부분 외부에 열어준 곳을 시작점으로 사용한다. 이런 이유로 public메서드에만 트랜잭션을 적용하도록 설정되어 있다.

스프링 부트 3.0 부터는 protected, package-visible(default 접근제한자)에도 트랜잭션이 적용된다.

댓글남기기

참고