22.11.21
트랜잭션 적용 위치
@Transactional 의 적용 위치에 따른 우선순위
스프링에서 우선순위는 항상 더 구체적이고 자세한 것이 높은 우선순위를 가진다.
예를 들어서 메서드와 클래스에 애노테이션을 붙일 수 있다면 더 구체적인 메서드가 더 높은 우선순위를 가진다.
인터페이스와 해당 인터페이스를 구현한 클래스에 애노테이션을 붙일 수 있다면 더 구체적인 클래스가 더 높은 우선순위를 가진다.
TxLevelTest
@SpringBootTest
@Slf4j
public class TxLevelTest {
@Autowired LevelService service;
@Test
void orderTest(){
service.write();
service.read();
}
@TestConfiguration
static class TxLevelTestConfig {
@Bean
LevelService levelService(){
return new LevelService();
}
}
@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 은 다음 두 가지 규칙이 있다.
- 우선순위 규칙
- 클래스에 적용하면 메서드는 자동 적용
우선순위
트랜잭션을 사용할 때는 다양한 옵션을 사용할 수 있다. 그런데 어떤 경우에는 옵션을 주고, 어떤 경우에는 옵션을 주지 않으면 어떤 것이 선택될까?
LevelService.write() 가 호출될 때는 타입에 있는 @Transactional(readOnly = true) 와 해당 메서드에 있는 @Transactional(readOnly = false) 둘 중 하나를 적용해야 한다.
클래스 보다는 메서드가 더 구체적이므로 메서드에 있는 @Transactional(readOnly = false) 옵션을 사용한 트랜잭션이 적용된다.
클래스에 적용하면 메서드는 자동 적용
read() : 해당 메서드에 @Transactional 이 없다.
이 경우 더 상위인 클래스를 확인한다. 클래스에 @Transactional(readOnly = true) 이 적용되어 있다. 따라서 트랜잭션이 적용되고 readOnly = true 옵션을 사용하게 된다.
참고: readOnly=false 는 기본 옵션(default)이기 때문에 보통 생략한다.
@Transactional == @Transactional(readOnly=false)
TransactionSynchronizationManager.isCurrentTransactionReadOnly
현재 트랜잭션에 적용된 readOnly 옵션의 값을 반환한다.
실행 결과
# write() 호출
TransactionInterceptor : Getting transaction for [..LevelService.write]
y.TxLevelTest$LevelService : call write
y.TxLevelTest$LevelService : tx active=true
y.TxLevelTest$LevelService : tx readOnly=false
TransactionInterceptor : Completing transaction for [..LevelService.write]
# read() 호출
TransactionInterceptor : Getting transaction for [..LevelService.read]
y.TxLevelTest$LevelService : call read
y.TxLevelTest$LevelService : tx active=true
y.TxLevelTest$LevelService : tx readOnly=true
TransactionInterceptor : Completing transaction for [..LevelService.read]인터페이스에 @Transactional 적용
인터페이스에도 @Transactional 을 적용할 수 있다. 이 경우 다음 순서로 적용된다.
- 클래스의 메서드 (우선순위가 가장 높다.)
- 클래스의 타입
- 인터페이스의 메서드
- 인터페이스의 타입 (우선순위가 가장 낮다.)
그런데 인터페이스에 @Transactional 사용하는 것은 스프링 공식 메뉴얼에서 권장하지 않는 방법이다.
AOP를 적용하는 방식에 따라서 인터페이스에 애노테이션을 두면 AOP가 적용이 되지 않는 경우도 있기 때문이다.
가급적 구체 클래스에 @Transactional 을 사용하자.
참고: 스프링은 인터페이스에 @Transactional 을 사용하는 방식을 스프링 5.0에서 많은 부분 개선했다. 과거에는 구체 클래스를 기반으로 프록시를 생성하는 CGLIB 방식을 사용하면 인터페이스에 있는 @Transactional 을 인식하지 못했다. 스프링 5.0 부터는 이 부분을 개선해서 인터페이스에 있는 @Transactional 도 인식한다. 하지만 다른 AOP 방식에서 또 적용되지 않을 수 있으므로 공식 메뉴얼의 가이드대로 가급적 구체 클래스에 @Transactional 을 사용하자.
트랜잭션 AOP 주의 사항 - 프록시 내부 호출1
참고: 여기서 설명하는 내용은 스프링 핵심원리 고급편 13. 실무 주의사항 - 프록시와 내부 호출 문제에서 다루는 내용과 같은 문제를 다룬다. 이렇게 한번 더 언급하는 이유는 그 만큼 실무에서 많이 만나는 주제이고, 많은 개발자들이 이 문제를 이해하지 못해서 고통받기 때문이다. 여기서는 트랜잭션 AOP에 관점에서 설명한다.
@Transactional 을 사용하면 스프링의 트랜잭션 AOP가 적용된다. 트랜잭션 AOP는 기본적으로 프록시 방식의 AOP를 사용한다. 앞서 배운 것 처럼 @Transactional 을 적용하면 프록시 객체가 요청을 먼저 받아서 트랜잭션을 처리하고, 실제 객체를 호출해준다. 따라서 트랜잭션을 적용하려면 항상 프록시를 통해서 대상 객체(Target)을 호출해야 한다.
만약 프록시를 거치지 않고 대상 객체를 직접 호출하게 되면 AOP가 적용되지 않고, 트랜잭션도 적용되지 않는다.
AOP를 적용하면 스프링은 대상 객체 대신에 프록시를 스프링 빈으로 등록한다. 따라서 스프링은 의존관계 주입시에 항상 실제 객체 대신에 프록시 객체를 주입한다. 프록시 객체가 주입되기 때문에 대상 객체를 직접 호출하는 문제는 일반적으로 발생하지 않는다.
하지만 대상 객체의 내부에서 메서드 호출이 발생하면 프록시를 거치지 않고 대상 객체를 직접 호출하는 문제가 발생한다. 이렇게 되면 @Transactional 이 있어도 트랜잭션이 적용되지 않는다.
InternalCallV1Test
@Slf4j
@SpringBootTest
public class InternalCallV1Test {
@Autowired CallService callService; //메서드에 @Transactional 이 있기 때문에 프록시가 주입된다.
@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();
}
}
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 빈을 주입 받으면 트랜잭션 프록시 객체가 대신 주입된다.
실행 로그 - printProxy()
callService class=class hello..InternalCallV1Test$CallService$$EnhancerBySpringCGLIB$$4ec3f332
internal() 실행
1. 클라이언트인 테스트 코드는 callService.internal() 을 호출한다. 여기서 callService 는 트랜잭션 프록시이다.
2. callService 의 트랜잭션 프록시가 호출된다.
3. internal() 메서드에 @Transactional 이 붙어 있으므로 트랜잭션 프록시는 트랜잭션을 적용한다.
4. 트랜잭션 적용 후 실제 callService 객체 인스턴스의 internal() 을 호출한다. 실제 callService 가 처리를 완료하면 응답이 트랜잭션 프록시로 돌아오고, 트랜잭션 프록시는 트랜잭션을 완료한다.
실행 로그
TransactionInterceptor : Getting transaction for [..CallService.internal]
..rnalCallV1Test$CallService : call internal
..rnalCallV1Test$CallService : tx active=true
TransactionInterceptor : Completing transaction for [..CallService.internal]
TransactionInterceptor 로그와 TransactionSynchronizationManager.isActualTransactionActive() = true 를 통해 트랜잭션이 실행되었음을 확인할 수 있다.
externalCall() 실행
external() 은 @Transactional 애노테이션이 없다. 따라서 트랜잭션 없이 시작한다.
그리고 내부에서 @Transactional 이 있는 internal() 을 호출해도 트랜잭션이 적용되지 않는다.
실행 로그
CallService : call external
CallService : tx active=false
CallService : call internal
CallService : tx active=falseTransactionSynchronizationManager.isActualTransactionActive() = false 로 @Transactional 애노테이션이 있는 internal() 을 호출해도 트랜잭션이 실행되지 않았다.
프록시와 내부 호출
1. 클라이언트인 테스트 코드는 callService.external() 을 호출한다. 여기서 callService 는 트랜잭션 프록시이다.
2. callService 의 트랜잭션 프록시가 호출된다.
3. external() 메서드에는 @Transactional 이 없다. 따라서 트랜잭션 프록시는 트랜잭션을 적용하지 않는다.
4. 트랜잭션 적용하지 않고, 실제 callService 객체 인스턴스의 external() 을 호출한다.
5. external() 은 내부에서 internal() 메서드를 호출한다. -> 프록시를 거치지 않고 this.internal() 호출
자바 언어에서 메서드 앞에 별도의 참조가 없으면 this 라는 뜻으로 자기 자신의 인스턴스를 가리킨다. 결과적으로 이러한 내부 호출은 프록시를 거치지 않는다. 따라서 트랜잭션을 적용할 수 없다.
프록시 방식의 AOP 한계
@Transactional 를 사용하는 트랜잭션 AOP는 프록시를 사용한다. 프록시를 사용하면 메서드 내부 호출에 프록시를 적용할 수 없다.
그렇다면 이 문제를 어떻게 해결할 수 있을까?
가장 단순한 방법은 내부 호출을 피하기 위해 internal() 메서드를 별도의 클래스로 분리하는 것이다.
트랜잭션 AOP 주의 사항 - 프록시 내부 호출2
메서드 내부 호출 때문에 트랜잭션 프록시가 적용되지 않는 문제를 해결하기 위해 internal() 메서드를 별도의 클래스로 분리하자.
InternalCallV2Test
@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();
}
}
@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 에는 트랜잭션 관련 코드가 전혀 없으므로 트랜잭션 프록시가 적용되지 않는다.
- //printProxy() 실행 로그 callService class=class hello.springtx.apply.InternalCallV2Test$CallService
- InternalService 에는 트랜잭션 관련 코드가 있으므로 트랜잭션 프록시가 적용된다.
1. 클라이언트인 테스트 코드는 callService.external() 을 호출한다.
2. callService 는 실제 callService 객체 인스턴스이다.
3. callService 는 주입 받은 internalService.internal() 을 호출한다.
4. internalService 는 트랜잭션 프록시이다. internal() 메서드에 @Transactional 이 붙어 있으므로 트랜잭션 프록시는 트랜잭션을 적용한다.
5. 트랜잭션 적용 후 실제 internalService 객체 인스턴스의 internal() 을 호출한다.
실행 로그 - externalCallV2()
..InternalCallV2Test$CallService : call external
..InternalCallV2Test$CallService : tx active=false
TransactionInterceptor : Getting transaction for [..InternalService.internal]
..rnalCallV2Test$InternalService : call internal
..rnalCallV2Test$InternalService : tx active=true
TransactionInterceptor : Completing transaction for [..InternalService.internal]
여러가지 다른 해결방안도 있지만, 실무에서는 이렇게 별도의 클래스로 분리하는 방법을 주로 사용한다.
스프링 핵심원리 고급편 13. 실무 주의사항 - 프록시와 내부 호출 문제에서 더 다양한 해결 방안을 소개한다.
public 메서드만 트랜잭션 적용
스프링의 트랜잭션 AOP 기능은 public 메서드에만 트랜잭션을 적용하도록 기본 설정이 되어있다. 그래서 protected , private , package-visible 에는 트랜잭션이 적용되지 않는다. 생각해보면 protected , package-visible 도 외부에서 호출이 가능하다. 따라서 이 부분은 앞서 설명한 프록시의 내부 호출과는 무관하고, 스프링이 막아둔 것이다.
스프링이 public 에만 트랜잭션을 적용하는 이유
@Transactional
public class Hello {
public method1();
method2();
protected method3();
private method4();
}이렇게 클래스 레벨에 트랜잭션을 적용하면 모든 메서드에 트랜잭션이 걸릴 수 있다. 그러면 트랜잭션을 의도하지 않는 곳 까지 트랜잭션이 과도하게 적용된다. 트랜잭션은 주로 비즈니스 로직의 시작점에 걸기 때문에 대부분 외부에 열어준 곳을 시작점으로 사용한다. 따라서 특정 영역에서만 사용하는 메서드에는 굳이 트랜잭션을 걸 이유가 없다.
앞서 실행했던 코드를 package-visible 로 변경해보면 적용되지 않는 것을 확인할 수 있다.
참고: public 이 아닌곳에 @Transactional 이 붙어 있으면 예외가 발생하지는 않고, 트랜잭션 적용만 무시된다.
트랜잭션 AOP 주의 사항 - 초기화 시점
스프링 초기화 시점에는 트랜잭션 AOP가 적용되지 않을 수 있다.
InitTxTest
@Slf4j
@SpringBootTest
public class InitTxTest {
@Autowired Hello hello;
@Test
void go(){
//@PostConstruct 초기화 코드는 스프링 초기화 시점에 호출된다.
//따라서 hello.initV1() 을 직접 호출하면 당연히 트랜잭션이 적용된다. (런타임 시점)
//@EventListener(ApplicationReadyEvent.class)
//트랜잭션 AOP를 포함한 스프링이 컨테이너가 완전히 생성된 후에 호출된다.
}
@TestConfiguration
static class InitTxTestConfig {
@Bean
Hello hello(){
return new Hello();
}
}
static class Hello {
@PostConstruct
@Transactional
public void initV1(){
boolean txActive = TransactionSynchronizationManager.isActualTransactionActive();
log.info("Hello init @PostConstruct tx active={}", txActive);
}
@EventListener(ApplicationReadyEvent.class)
@Transactional
public void initV2(){
boolean txActive = TransactionSynchronizationManager.isActualTransactionActive();
log.info("Hello init ApplicationReadyEvent tx active={}", txActive);
}
}
}
initV1()
스프링 초기화 시점에 호출
초기화 코드(예: @PostConstruct )와 @Transactional 을 함께 사용하면 트랜잭션이 적용되지 않는다.
왜냐하면 초기화 코드가 먼저 호출되고, 그 다음에 트랜잭션 AOP가 적용되기 때문이다. 따라서 초기화 시점에는 해당 메서드에서 트랜잭션을 획득할 수 없다.
Hello init @PostConstruct tx active=false
initV2()
ApplicationReadyEvent 이벤트가 호출
ApplicationReadyEvent 이벤트는 트랜잭션 AOP를 포함한 스프링이 컨테이너가 완전히 생성되고 난 다음에 이벤트가 붙은 메서드를 호출해준다. 따라서 init2() 는 트랜잭션이 적용된다.
InitTxTest : Hello init @PostConstruct tx active=false
InitTxTest : Started InitTxTest in 4.834 seconds (JVM running for 6.808)
TransactionInterceptor : Getting transaction for [..InitTxTest$Hello.initV2]
InitTxTest : Hello init ApplicationReadyEvent tx active=true트랜잭션 옵션 소개
스프링 트랜잭션은 다양한 옵션을 제공한다.
@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 : 직렬화 가능
참고: 강의에서는 일반적으로 많이 사용하는 READ COMMITTED(커밋된 읽기) 트랜잭션 격리 수준을 기준으로 설명한다.
트랜잭션 격리 수준은 데이터베이스에 자체에 관한 부분이어서 이 강의 내용을 넘어선다.
timeout
트랜잭션 수행 시간에 대한 타임아웃을 초 단위로 지정한다. 기본 값은 트랜잭션 시스템의 타임아웃을 사용한다. 운영 환경에 따라 동작하는 경우도 있고 그렇지 않은 경우도 있기 때문에 꼭 확인하고 사용해야 한다.
timeoutString 도 있는데, 숫자 대신 문자 값으로 지정할 수 있다.
label
트랜잭션 애노테이션에 있는 값을 직접 읽어서 어떤 동작을 하고 싶을 때 사용할 수 있다. 일반적으로 사용하지 않는다.
readOnly
트랜잭션은 기본적으로 읽기 쓰기가 모두 가능한 트랜잭션이 생성된다.
readOnly=true 옵션을 사용하면 읽기 전용 트랜잭션이 생성된다. 이 경우 등록, 수정, 삭제가 안되고 읽기 기능만 작동한다. (드라이버나 데이터베이스에 따라 정상 동작하지 않는 경우도 있다.) 그리고 readOnly 옵션을 사용하면 읽기에서 다양한 성능 최적화가 발생할 수 있다.
readOnly 옵션은 크게 3곳에서 적용된다.
1. 프레임워크
- JdbcTemplate은 읽기 전용 트랜잭션 안에서 변경 기능을 실행하면 예외를 던진다.
- JPA(하이버네이트)는 읽기 전용 트랜잭션의 경우 커밋 시점에 플러시를 호출하지 않는다. 읽기 전용이니 변경에 사용되는 플러시(변경 쿼리)를 호출할 필요가 없다. 추가로 변경이 필요 없으니 변경 감지를 위한 스냅샷 객체도 생성하지 않는다. 이렇게 JPA에서는 다양한 최적화가 발생한다.
2. JDBC 드라이버
- JDBC 드라이버에 관한 내용들은 DB와 드라이버 버전에 따라서 다르게 동작하기 때문에 사전에 확인이 필요하다.
- 읽기 전용 트랜잭션에서 변경 쿼리가 발생하면 예외를 던진다.
- 읽기, 쓰기(마스터, 슬레이브) 데이터베이스를 구분해서 요청한다. 읽기 전용 트랜잭션의 경우 읽기 (슬레이브) 데이터베이스의 커넥션을 획득해서 사용한다. 예) https://dev.mysql.com/doc/connector-j/8.0/en/connector-j-source-replica-replication-connection.html
3. 데이터베이스
- 데이터베이스에 따라 읽기 전용 트랜잭션의 경우 읽기만 하면 되므로, 내부에서 성능 최적화가 발생한다.
참고: 환경에 따라 readOnly = true 로 오히려 성능이 느려질 수도 있다. 데이터베이스에 따라, 로직에 따라 다르기 때문에 성능테스트가 필요하다. JdbcTemplate 으로 SQL만 사용한다면 성능상 큰 차이가 없을 수도 있다. 일반적으로는 성능 최적화가 이루어진다.
예외와 트랜잭션 커밋, 롤백 - 기본
예외가 발생했는데, 내부에서 예외를 처리하지 못하고, 트랜잭션 범위( @Transactional가 적용된 AOP ) 밖으로 예외를 던지면 어떻게 될까?
예외 발생시 스프링 트랜잭션 AOP는 예외의 종류에 따라 트랜잭션을 커밋하거나 롤백한다.
- 언체크 예외인 RuntimeException , Error 와 그 하위 예외가 발생하면 트랜잭션을 롤백한다.
- 체크 예외인 Exception 과 그 하위 예외가 발생하면 트랜잭션을 커밋한다.
- 물론 정상 응답(리턴)하면 트랜잭션을 커밋한다.
RollbackTest
@SpringBootTest
public class RollbackTest {
@Autowired RollbackService service;
@Test
void runtimeException(){
service.runtimeException();
}
@TestConfiguration
static class RollbackTestConfig {
@Bean
RollbackService rollbackService(){
return new RollbackService();
}
}
@Slf4j
static class RollbackService {
//런타임 예외 발생 -> 롤백
@Transactional
public void runtimeException(){
log.info("call runtimeException");
throw new RuntimeException();
}
//체크 예외 발생 -> 커밋
@Transactional
public void checkedException() throws MyException {
log.info("call checkedException");
throw new MyException();
}
//체크 예외 발생 rollbackFor 지정 -> 롤백
@Transactional(rollbackFor = MyException.class)
public void rollbackFor() throws MyException {
log.info("call rollbackFor");
throw new MyException();
}
}
static class MyException extends Exception {
}
}
logging.level.org.springframework.transaction.interceptor=TRACE
트랜잭션 AOP 가 남겨주는 로그에서는 트랜잭션의 시작과 종료만 확인할 수 있다. 트랜잭션의 종료는 커밋이나 롤백이 되는 경우이며, 이를 확인하기 위해 아래 옵션을 추가한다.
application.properties - 로그 추가
logging.level.org.springframework.transaction.interceptor=TRACE
logging.level.org.springframework.jdbc.datasource.DataSourceTransactionManager=DEBUG
#JPA log
logging.level.org.springframework.orm.jpa.JpaTransactionManager=DEBUG
logging.level.org.hibernate.resource.transaction=DEBUG지금은 JPA를 사용하므로 트랜잭션 매니저로 JpaTransactionManager 가 실행되고, 여기의 로그를 출력하게 된다.
runtimeException() 실행 - 런타임 예외
Getting transaction for [...RollbackService.runtimeException]
call runtimeException
Completing transaction for [...RollbackService.runtimeException] after exception: RuntimeException
Initiating transaction rollback
Rolling back JPA transaction on EntityManagerRuntimeException 이 발생하므로 트랜잭션이 롤백된다.
checkedException() 실행 - 체크 예외
Getting transaction for [...RollbackService.checkedException]
call checkedException
Completing transaction for [...RollbackService.checkedException] after exception: MyException
Initiating transaction commit
Committing JPA transaction on EntityManagerMyException 은 Exception 을 상속받은 체크 예외이다. 따라서 예외가 발생해도 트랜잭션이 커밋된다.
rollbackFor
이 옵션을 사용하면 기본 정책에 추가로 어떤 예외가 발생할 때 롤백할지 지정할 수 있다.
@Transactional(rollbackFor = Exception.class)
예를 들어서 이렇게 지정하면 체크 예외인 Exception 이 발생해도 커밋 대신 롤백된다. (자식 타입도 롤백된다.)
rollbackFor() 실행 - 체크 예외를 강제로 롤백
rollbackFor = MyException.class 을 지정했기 때문에 MyException 이 발생하면 체크 예외이지만 트랜잭션이 롤백된다.
Getting transaction for [...RollbackService.rollbackFor]
call rollbackFor
Completing transaction for [...RollbackService.rollbackFor] after exception: MyException
Initiating transaction rollback
Rolling back JPA transaction on EntityManager예외와 트랜잭션 커밋, 롤백 - 활용
스프링은 왜 체크 예외는 커밋하고, 언체크(런타임) 예외는 롤백할까?
스프링 기본적으로 각 예외에 대해 다음과 같이 가정한다.
- 체크 예외: 비즈니스 의미가 있을 때 사용
- 언체크 예외: 복구 불가능한 예외 ex) 데이터베이스 접근 불가, SQL 문법 오류, 네트워크 통신 오류 등
꼭 이런 정책을 따를 필요는 없다. 그때는 rollbackFor 라는 옵션을 사용해서 체크 예외도 롤백하면 된다.
비즈니스 요구사항
주문을 하는데 상황에 따라 다음과 같이 조치한다.
- 정상: 주문시 결제를 성공하면 주문 데이터를 저장하고 결제 상태를 '완료'로 처리한다.
- 시스템 예외: 주문시 내부에 복구 불가능한 예외가 발생하면 전체 데이터를 롤백한다.
- 비즈니스 예외: 주문시 결제 잔고가 부족하면 주문 데이터를 저장하고, 결제 상태를 '대기' 로 처리한다. 이 경우 고객에게 잔고 부족을 알리고 별도의 계좌로 입금하도록 안내한다. (주문 데이터 필요, 커밋)
이때 결제 잔고가 부족하면 NotEnoughMoneyException 이라는 체크 예외가 발생한다고 가정하겠다. 이 예외는 시스템에 문제가 있어서 발생하는 시스템 예외가 아니다. 시스템은 정상 동작했지만, 비즈니스 상황에서 문제가 되기 때문에 발생한 예외이다. 이런 예외를 비즈니스 예외라 한다. 그리고 비즈니스 예외는 매우 중요하고, 반드시 처리해야 하는 경우가 많으므로 체크 예외를 고려할 수 있다.
NotEnoughMoneyException
결제 잔고가 부족하면 발생하는 비즈니스 예외이다. Exception 을 상속 받아서 체크 예외가 된다.
public class NotEnoughMoneyException extends Exception {
public NotEnoughMoneyException(String message) {
super(message);
}
}Order
@Entity
@Table(name = "orders")
@Getter @Setter
public class Order {
@Id
@GeneratedValue
private Long id;
private String username; //정상, 예외, 잔고부족
private String payStatus; //대기, 완료
}
- JPA를 사용하는 Order 엔티티이다.
- 예제를 단순하게 하기 위해 @Getter , @Setter 를 사용했다. 실무에서 엔티티에 @Setter 를 남발해서 불필요한 변경 포인트를 노출하는 것은 좋지 않다.
- 주의! @Table(name = "orders") 라고 했는데, 테이블 이름을 지정하지 않으면 테이블 이름이 클래스 이름인 order 가 된다. order 는 데이터베이스 예약어( order by )여서 사용할 수 없기 때문에 orders 라는 테이블 이름을 따로 지정해주었다.
OrderRepository
스프링 데이터 JPA를 사용하는 리포지토리 (인터페이스)
public interface OrderRepository extends JpaRepository<Order, Long> {
}OrderService
@Slf4j
@Service
@RequiredArgsConstructor
public class OrderService {
private final OrderRepository orderRepository;
//JPA는 트랜잭션 커밋 시점에 Order 데이터를 DB에 반영한다.
@Transactional
public void order(Order order) throws NotEnoughMoneyException {
log.info("order 호출");
orderRepository.save(order);
log.info("결제 프로세스 진입");
if (order.getUsername().equals("예외")) {
log.info("시스템 예외 발생");
throw new RuntimeException("시스템 예외");
} else if (order.getUsername().equals("잔고부족")) {
log.info("잔고 부족 비지니스 예외 발생");
order.setPayStatus("대기");
throw new NotEnoughMoneyException("잔고가 부족합니다");
} else {
log.info("정상 승인");
order.setPayStatus("완료");
}
}
}
여러 상황을 만들기 위해서 사용자 이름( username )에 따라서 처리 프로세스를 다르게 했다.
- 기본: payStatus 를 완료 상태로 처리하고 정상 처리된다.
- 예외: RuntimeException("시스템 예외") 런타임 예외가 발생한다.
- 잔고부족
- payStatus 를 대기 상태로 처리한다.
- NotEnoughMoneyException("잔고가 부족합니다") 체크 예외가 발생한다.
- 잔고 부족은 payStatus 를 대기 상태로 두고, 체크 예외가 발생하지만, order 데이터는 커밋되기를 기대한다.
application.properties - 로그 옵션 추가
#JPA SQL
logging.level.org.hibernate.SQL=DEBUG테스트 전에 해당 옵션을 추가한다. JPA(하이버네이트)가 실행하는 SQL을 로그로 확인할 수 있다.
OrderServiceTest
@Slf4j
@SpringBootTest
class OrderServiceTest {
@Autowired OrderService orderService;
@Autowired OrderRepository orderRepository;
@Test
void complete() throws NotEnoughMoneyException {
Order order = new Order();
order.setUsername("정상");
orderService.order(order);
Order findOrder = orderRepository.findById(order.getId()).get();
Assertions.assertThat(findOrder.getPayStatus()).isEqualTo("완료");
}
@Test
void runtimeException() {
Order order = new Order();
order.setUsername("예외");
Assertions.assertThatThrownBy(() -> orderService.order(order))
.isInstanceOf(RuntimeException.class); //롤백 수행
Optional<Order> orderOptional = orderRepository.findById(order.getId());
Assertions.assertThat(orderOptional.isEmpty()).isTrue();
}
@Test
void bizException() {
Order order = new Order();
order.setUsername("잔고부족");
try {
orderService.order(order);
} catch (NotEnoughMoneyException e) {
log.info("고객에게 잔고 부족을 알리고 별도의 계좌로 입금하도록 안내");
}
Order findOrder = orderRepository.findById(order.getId()).get();
Assertions.assertThat(findOrder.getPayStatus()).isEqualTo("대기");
}
}
메모리 DB를 통해 테스트를 수행하면 테이블 자동 생성 옵션이 활성화 된다. JPA는 엔티티 정보를 참고해서 테이블을 자동으로 생성해준다.
참고: 테이블 자동 생성 옵션
테이블 자동 생성은 application.properties 에 spring.jpa.hibernate.ddl-auto 옵션으로 조정할 수 있다.
- none : 테이블을 생성하지 않는다.
- create : 애플리케이션 시작 시점에 테이블을 생성한다.
complete()
사용자 이름을 "정상" 으로 설정했다. 주문 과정에서 모든 프로세스가 정상 수행된다.
assertThat(findOrder.getPayStatus()).isEqualTo("완료"); -> 검증 성공
runtimeException()
사용자 이름을 "예외" 로 설정했다. RuntimeException("시스템 예외") 이 발생한다.
런타임 예외로 롤백이 수행되었기 때문에 Order 데이터가 비어 있는 것을 확인할 수 있다.
bizException()
사용자 이름을 "잔고부족" 으로 설정했다. NotEnoughMoneyException("잔고가 부족합니다") 이 발생한다.
체크 예외로 커밋이 수행되었기 때문에 Order 데이터가 저장된다.
assertThat(findOrder.getPayStatus()).isEqualTo("대기"); -> 검증 성공
정리
- NotEnoughMoneyException 은 시스템에 문제가 발생한 것이 아니라, 비즈니스 문제 상황을 예외를 통해 알려준다. 마치 예외가 리턴 값 처럼 사용된다. (리턴 값으로 처리해도 무관하다. 예외로 한 것은 반드시 처리해야 하고 중요하다는 의미+스프링에서 커밋, 롤백을 자동으로 처리해줌)
- 위 예제에서 롤백하면 생성한 Order 자체가 사라지기 때문에 트랜잭션을 커밋하는 것이 맞다. 만약 롤백되면 고객에게 잔고 부족을 알리고 별도의 계좌로 입금하도록 안내해도 주문( Order ) 자체가 사라지기 때문에 문제가 된다.
- 런타임 예외는 항상 롤백된다. 체크 예외의 경우 rollbackFor 옵션을 사용해서 비즈니스 상황에 따라서 커밋과 롤백을 선택하면 된다. (옵션으로 예외성을 두는 것보다는 스프링에서 설정한 대로 사용하는 것이 복잡성을 줄일 수 있다. 가끔 필요한 경우에는 유용한 옵션이다.)