Spring DB - 스프링 트랜잭션 이해

Kwon Yongho·2023년 5월 25일
Spring DB
0

Spring-DB

목록 보기
14/16
post-thumbnail

스프링 트랜잭션 이해

  1. 스프링 트랜잭션 소개
  2. 프로젝트 생성
  3. 트랜잭션 적용 확인
  4. 트랜잭션 적용 위치
  5. 트랜잭션 AOP 주의 사항 - 프록시 내부 호출1
  6. 트랜잭션 AOP 주의 사항 - 프록시 내부 호출2
  7. 트랜잭션 AOP 주의 사항 - 초기화 시점
  8. 트랜잭션 옵션 소개
  9. 예외와 트랜잭션 커밋, 롤백 - 기본
  10. 예외와 트랜잭션 커밋, 롤백 - 활용

1. 스프링 트랜잭션 소개

스프링 트랜잭션을 간단히 복습 해보자.

스프링 트랜잭션 추상화
각각의 데이터 접근 기술들은 트랜잭션을 처리하는 방식에 차이가 있다. 예를 들어 JDBC 기술과 JPA 기술은 트랜잭션을 사용하는 코드 자체가 다르다.

JDBC 트랜잭션

	public void accountTransfer(String fromId, String toId, int money) throws
			SQLException {
		Connection con = dataSource.getConnection();
		try {
			con.setAutoCommit(false); //트랜잭션 시작
			//비즈니스 로직
			bizLogic(con, fromId, toId, money);
			con.commit(); //성공시 커밋
		} catch (Exception e) {
			con.rollback(); //실패시 롤백
			throw new IllegalStateException(e);
		} finally {
			release(con);
		}
	}

JPA 트랜잭션

	public static void main(String[] args) {
		//엔티티 매니저 팩토리 생성
		EntityManagerFactory emf = Persistence.createEntityManagerFactory("jpabook");
		EntityManager em = emf.createEntityManager(); //엔티티 매니저 생성
		EntityTransaction tx = em.getTransaction(); //트랜잭션 기능 획득
		try {
			tx.begin(); //트랜잭션 시작
			logic(em); //비즈니스 로직
			tx.commit();//트랜잭션 커밋
		} catch (Exception e) {
			tx.rollback(); //트랜잭션 롤백
		} finally {
			em.close(); //엔티티 매니저 종료
		}
		emf.close(); //엔티티 매니저 팩토리 종료
	}
  • 따라서 JDBC 기술을 사용하다가 JPA 기술로 변경하게 되면 트랜잭션을 사용하는 코드도 모두 함께 변경해야 한다.
  • 스프링은 이런 문제를 해결하기 위해 트랜잭션 추상화를 제공한다.
  • 트랜잭션 추상화를 통해 둘을 동일한 방식으로 사용할 수 있게 되는 것이다.

  • 스프링은 트랜잭션을 추상화해서 제공할 뿐만 아니라, 실무에서 주로 사용하는 데이터 접근 기술에 대한 트랜잭션 매니저의 구현체도 제공한다. 우리는 필요한 구현체를 스프링 빈으로 등록하고 주입 받아서 사용하기만 하면 된다.

스프링 트랜잭션 사용 방식

  • 선언적 트랜잭션 관리(Declarative Transaction Management)
    • @Transactional애노테이션 하나만 선언해서 매우 편리하게 트랜잭션을 적용하는 것을 선언적 트랜잭션 관리라 한다.
    • 이름 그대로 해당 로직에 트랜잭션을 적용하겠다 라고 어딘가에 선언하기만 하면 트랜잭션이 적용되는 방식이다.
  • 프로그래밍 방식의 트랜잭션 관리(programmatic transaction management)
    • 트랜잭션 매니저 또는 트랜잭션 템플릿 등을 사용해서 트랜잭션 관련 코드를 직접 작성하는 것을 프로그래밍 방식의 트랜잭션 관리라 한다.

선언적 트랜잭션 관리가 프로그래밍 방식에 비해서 훨씬 간편하고 실용적이기 때문에 실무에서는 대부분 선언적 트랜잭션 관리를 사용한다.

선언적 트랜잭션과 AOP

프록시 도입 전

프록시 도입 후

  • 트랜잭션을 처리하기 위한 프록시를 적용하면 트랜잭션을 처리하는 객체와 비즈니스 로직을 처리하는 서비스 객체를 명확하게 분리할 수 있다.

스프링이 제공하는 트랜잭션 AOP

  • 스프링의 트랜잭션은 매우 중요한 기능이고, 전세계 누구나 다 사용하는 기능이다. 스프링은 트랜잭션 AOP를 처리하기 위한 모든 기능을 제공한다. 스프링 부트를 사용하면 트랜잭션 AOP를 처리하기 위해 필요한 스프링 빈들도 자동으로 등록해준다.
  • 개발자는 트랜잭션 처리가 필요한 곳에 @Transactional애노테이션만 붙여주면 된다. 스프링의 트랜잭션 AOP는 이 애노테이션을 인식해서 트랜잭션을 처리하는 프록시를 적용해준다.

2. 프로젝트 생성

spring-transactional 프로젝트를 새로 생성 하였습니다.

3. 트랜잭션 적용 확인

@Transactional을 통해 선언적 트랜잭션 방식을 사용하면 단순히 애노테이션 하나로 트랜잭션을 적용할 수 있다. 그런데 이 기능은 트랜잭션 관련 코드가 눈에 보이지 않고, AOP를 기반으로 동작하기 때문에, 실제 트랜잭션이 적용되고 있는지 아닌지를 확인하기가 어렵다.

한번 트랜잭션이 잘 적용되고 있는지 확인해보자.
TxApplyBasicTest

package com.example.springtransactional.apply;

import lombok.extern.slf4j.Slf4j;
import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.Test;
import org.springframework.aop.support.AopUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.context.TestConfiguration;
import org.springframework.context.annotation.Bean;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.support.TransactionSynchronizationManager;

@Slf4j
@SpringBootTest
public class TxApplyBasicTest {

    @Autowired
    BasicService basicService;

    @Test
    void proxyCheck(){
        log.info("Aop class={}", basicService.getClass());
        Assertions.assertThat(AopUtils.isAopProxy(basicService)).isTrue();
    }

    @Test
    void txTest() {
        basicService.tx();
        basicService.nonTx();
    }

    @TestConfiguration
    static class TxApplyBasicConfig{

        @Bean
        BasicService basicService(){
            return new BasicService();
        }
    }

    @Slf4j
    static class BasicService{

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

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

proxyCheck()

  • AopUtils.isAopProxy() : 선언적 트랜잭션 방식에서 스프링 트랜잭션은 AOP를 기반으로 동작한다. @Transactional 을 메서드나 클래스에 붙이면 해당 객체는 트랜잭션 AOP 적용의 대상이 되고, 결과적으로 실제 객체 대신에 트랜잭션을 처리해주는 프록시 객체가 스프링 빈에 등록된다. 그리고 주입을 받을 때도 실제 객체 대신에 프록시 객체가 주입된다.
  • 클래스 이름을 출력해보면 basicService$$EnhancerBySpringCGLIB... 라고 프-록시 클래스의 이름이 출력되는 것을 확인할 수 있다.

txTest()

TransactionSynchronizationManager.isActualTransactionActive()

  • 현재 쓰레드에 트랜잭션이 적용되어 있는지 확인할 수 있는 기능이다. 결과가 true면 트랜잭션이 적용되어 있는 것이다. 트랜잭션의 적용 여부를 가장 확실하게 확인할 수 있다.

basicService.tx() 호출

  • 클라이언트가 basicService.tx() 를 호출하면, 프록시의 tx()가 호출된다. 여기서 프록시는 tx()메서드가 트랜잭션을 사용할 수 있는지 확인해본다. tx()메서드에는 @Transactional이 붙어있으므로 트랜잭션 적용 대상이다.
  • 따라서 트랜잭션을 시작한 다음에 실제 basicService.tx()를 호출한다.
  • 실제 basicService.tx()의 호출이 끝나서 프록시로 제어가(리턴) 돌아오면 프록시는 트랜잭션 로직을 커밋하거나 롤백해서 트랜잭션을 종료한다.

basicService.nonTx() 호출

  • 클라이언트가 basicService.nonTx()를 호출하면, 트랜잭션 프록시의 nonTx()가 호출된다. 여기서 nonTx()메서드가 트랜잭션을 사용할 수 있는지 확인해본다. nonTx()에는 @Transactional이 없으므로 적용 대상이 아니다.
  • 따라서 트랜잭션을 시작하지 않고, basicService.nonTx()를 호출하고 종료한다.

4. 트랜잭션 적용 위치

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

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

TxLevelTest

package com.example.springtransactional.apply;

import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.context.TestConfiguration;
import org.springframework.context.annotation.Bean;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.support.TransactionSynchronizationManager;

@SpringBootTest
public class TxLevelTest {

    @Autowired
    LevelService service;

    @Test
    void orderTest() {
        service.write();
        service.read();
    }

    @TestConfiguration
    static class TxApplyLevelConfig {

        @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("readOnly={}", readOnly);
        }

    }
}

스프링의 @Transactional은 다음 두 가지 규칙이 있다.
1. 우선순위 규칙
2. 클래스에 적용하면 메서드는 자동 적용

우선 순위 규칙

  • 트랜잭션을 사용할 때는 다양한 옵션을 사용할 수 있다.
  • 옵션 별 우선 순위는 어떻게 될까?
  • LevelService의 타입에 @Transactional(readOnly = true)이 붙어있다.
  • write(): 해당 메서드에 @Transactional(readOnly = false)이 붙어있다.
    • 클래스 보다는 메서드가 더 구체적이므로 메서드에 있는 @Transactional(readOnly = false) 옵션을 사용한 트랜잭션이 적용된다.

클래스에 적용하면 메서드는 자동 적용
read(): 해당 메서드에 @Transactional이 없다. 이 경우 더 상위인 클래스를 확인한다. 클래스에 @Transactional(readOnly = true)이 적용되어 있다. 따라서 트랜잭션이 적용되고 readOnly = true옵션을 사용하게 된다.

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

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

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

  • @Transactional을 사용하면 스프링의 트랜잭션 AOP가 적용된다.
  • 트랜잭션 AOP는 기본적으로 프록시 방식의 AOP를 사용한다.
  • @Transactional을 적용하면 프록시 객체가 요청을 먼저 받아서 트랜잭션을 처리하고, 실제 객체를 호출해준다.
  • 트랜잭션을 적용하려면 항상 프록시를 통해서 대상 객체(Target)을 호출해야 한다.

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

예제를 통해 내부 호출이 발생하는 예제를 만들고 확인해보자

InternalCallV1Test

package com.example.springtransactional.apply;

import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.context.TestConfiguration;
import org.springframework.context.annotation.Bean;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.support.TransactionSynchronizationManager;

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

        // Transactional x
        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);
        }

    }
}

internalCall() 실행 Transactional (O) - 기존 코드

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

externalCall() 실행 Transactional (X)

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

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

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


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는 프록시를 사용한다. 프록시를 사용하면 메서드 내부 호출에 프록시를 적용할 수 없다.

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

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

InternalCallV2Test

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

호출되는 흐름

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

public 메서드만 트랜잭션 적용

  • 스프링의 트랜잭션 AOP 기능은 public 메서드에만 트랜잭션을 적용하도록 기본 설정이 되어있다.
  • protected, private, package-visible에는 트랜잭션이 적용되지 않는다.

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

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

InitTxTest

package com.example.springtransactional.apply;

import jakarta.annotation.PostConstruct;
import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.context.event.ApplicationReadyEvent;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.context.TestConfiguration;
import org.springframework.context.annotation.Bean;
import org.springframework.context.event.EventListener;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.support.TransactionSynchronizationManager;

@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을 함께 사용하면 트랜잭션이 적용되지 않는다.
  • 왜냐하면 초기화 코드가 먼저 호출되고, 그 다음에 트랜잭션 AOP가 적용되기 때문이다. 따라서 초기화 시점에는 해당 메서드에서 트랜잭션을 획득할 수 없다.
  • V2 이벤트는 트랜잭션 AOP를 포함한 스프링이 컨테이너가 완전히 생성되고 난 다음에 이벤트가 붙은 메서드를 호출해준다. 따라서 init2()는 트랜잭션이 적용된 것을 확인할 수 있다.

8. 트랜잭션 옵션 소개

스프링 트랜잭션은 다양한 옵션을 제공한다. 이번 시간에는 각각의 옵션들을 간략하게 소개하겠다. 추후 자세히 알아보겠다.

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 둘 중 하나에 트랜잭션 매니저의 스프링 빈의 이름을 적어주면 된다.
  • 대부분 생략가능 둘 이상이라면 트랜잭션 매니저의 이름을 지정해줘야 한다.

rollbackFor

  • 언체크 예외인 RuntimeException, Error와 그 하위 예외가 발생하면 롤백한다.
  • 체크 예외인 Exception과 그 하위 예외들은 커밋한다.
  • 옵션을 사용하면 기본 정책에 추가로 어떤 예외가 발생할 때 롤백할 지 지정할 수 있다.

noRollbackFor

  • 앞서 설명한 rollbackFor와 반대이다. 기본 정책에 추가로 어떤 예외가 발생했을 때 롤백하면 안되는지 지정할 수 있다.

propagation

  • 뒤에서 자세히 설명해보겠습니다.

isolation

  • 트랜잭션 격리 수준을 지정할 수 있다. 기본 값은 데이터베이스에서 설정한 트랜잭션 격리 수준을 사용하는 DEFAULT이다.

timeout

  • 트랜잭션 수행 시간에 대한 타임아웃을 초 단위로 지정한다.
  • 기본 값은 트랜잭션 시스템의 타임아웃을 사용한다.

readOnly

  • 트랜잭션은 기본적으로 읽기 쓰기가 모두 가능한 트랜잭션이 생성된다.
  • readOnly=true옵션을 사용하면 읽기 전용 트랜잭션이 생성된다. 이 경우 등록, 수정, 삭제가 안되고 읽기 기능만 작동한다. (드라이버나 데이터베이스에 따라 정상 동작하지 않는 경우도 있다.)

9. 예외와 트랜잭션 커밋, 롤백 - 기본

예외가 발생했는데, 내부에서 예외를 처리하지 못하고, 트랜잭션 범위(@Transactional가 적용된 AOP) 밖으로 예외를 던지면 어떻게 될까?

예외 발생시 스프링 트랜잭션 AOP는 예외의 종류에 따라 트랜잭션을 커밋하거나 롤백한다.

  • 언체크 예외인 RuntimeException, Error와 그 하위 예외가 발생하면 트랜잭션을 롤백한다.
  • 체크 예외인 Exception과 그 하위 예외가 발생하면 트랜잭션을 커밋한다.
  • 물론 정상 응답(리턴)하면 트랜잭션을 커밋한다.

RollbackTest

package com.example.springtransactional.apply;

import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.context.TestConfiguration;
import org.springframework.context.annotation.Bean;
import org.springframework.transaction.annotation.Transactional;

import static org.assertj.core.api.Assertions.assertThatThrownBy;

@SpringBootTest
public class RollbackTest {

    @Autowired
    RollbackService service;

    // 런타임 예외
    @Test
    void runtimeException() {
        assertThatThrownBy(() -> service.runtimeException()).isInstanceOf(RuntimeException.class);
    }

    // 체크 예외
    @Test
    void checkedException() {
        assertThatThrownBy(() -> service.checkedException()).isInstanceOf(MyException.class);
    }

    // 체크 예외를 강제로 롤백
    @Test
    void rollbackFor() {
        assertThatThrownBy(() -> service.rollbackFor()).isInstanceOf(MyException.class);
    }

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

runtimeException() 실행 - 런타임 예외

  • RuntimeException이 발생하므로 트랜잭션이 롤백된다.

checkedException() 실행 - 체크 예외

  • MyException은 Exception을 상속받은 체크 예외이다. 따라서 예외가 발생해도 트랜잭션이 커밋된다.

rollbackFor() 실행 - 체크 예외를 강제로 롤백

  • 기본 정책과 무관하게 특정 예외를 강제로 롤백하고 싶으면 rollbackFor 를 사용하면 된다. (해당 예외의 자식도 포함된다.)
  • rollbackFor = MyException.class을 지정했기 때문에 MyException이 발생하면 체크 예외이지만 트랜잭션이 롤백된다.

10. 예외와 트랜잭션 커밋, 롤백 - 활용

스프링은 왜 체크 예외는 커밋하고, 언체크(런타임) 예외는 롤백할까?

  • 스프링 기본적으로 체크 예외는 비즈니스 의미가 있을 때 사용하고, 런타임(언체크) 예외는 복구 불가능한 예외로 가정한다.

비즈니스 요구사항
주문을 하는데 상황에 따라 다음과 같이 조치
1. 정상: 주문시 결제를 성공하면 주문 데이터를 저장하고 결제 상태를 완료로 처리한다.
2. 시스템 예외: 주문시 내부에 복구 불가능한 예외가 발생하면 전체 데이터를 롤백한다.
3. 비즈니스 예외: 주문시 결제 잔고가 부족하면 주문 데이터를 저장하고, 결제 상태를 대기로 처리한다. 이 경우 고객에게 잔고 부족을 알리고 별도의 계좌로 입금하도록 안내한다.

결제 잔고가 부족하면 NotEnoughMoneyException이라는 체크 예외가 발생한다고 가정하겠다.

NotEnoughMoneyException

package com.example.springtransactional.order;

// 결제 잔고가 부족하면 발생하는 비즈니스 예외이다.
// 체크 예외
public class NotEnoughMoneyException extends Exception {
    public NotEnoughMoneyException(String message) {
        super(message);
    }
}

Order

package com.example.springtransactional.order;

import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.Id;
import jakarta.persistence.Table;
import lombok.Getter;
import lombok.Setter;

@Entity
@Table(name = "orders")
@Getter
@Setter
public class Order {
    @Id
    @GeneratedValue
    private Long id;
    private String username; //정상, 예외, 잔고부족
    private String payStatus; //대기, 완료
}
  • JPA를 사용하는 Order엔티티이다

OrderRepository

package com.example.springtransactional.order;

import org.springframework.data.jpa.repository.JpaRepository;

public interface OrderRepository extends JpaRepository<Order, Long> {
}
  • 스프링 데이터 JPA를 사용

OrderService

package com.example.springtransactional.order;

import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@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("결제 프로세스 진입");

        // 사용자 이름(username)에 따라서 처리 프로세스를 다르게 했다.
        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("완료");
        }
        log.info("결제 프로세스 완료");
    }
}
  • 기본 : payStatus를 완료 상태로 처리하고 정상 처리된다.
  • 예외 : RuntimeException("시스템 예외") 런타임 예외가 발생한다.
  • 잔고부족
    • payStatus를 대기 상태로 처리한다.
    • NotEnoughMoneyException("잔고가 부족합니다") 체크 예외가 발생한다.
    • 잔고 부족은 payStatus를 대기 상태로 두고, 체크 예외가 발생하지만, order데이터는 커밋되기를 기대한다.

OrderServiceTest

package com.example.springtransactional.order;

import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.Optional;

import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.junit.jupiter.api.Assertions.fail;

@Slf4j
@SpringBootTest
class OrderServiceTest {

    @Autowired
    OrderService orderService;
    @Autowired
    OrderRepository orderRepository;

    @Test
    void complete() throws NotEnoughMoneyException {
        //given
        Order order = new Order();
        order.setUsername("정상");

        //when
        orderService.order(order);

        //then
        Order findOrder = orderRepository.findById(order.getId()).get();
        assertThat(findOrder.getPayStatus()).isEqualTo("완료");
    }

    @Test
    void runtimeException() {
        //given
        Order order = new Order();
        order.setUsername("예외");

        //when, then
        assertThatThrownBy(() -> orderService.order(order)).isInstanceOf(RuntimeException.class);

        //then: 롤백되었으므로 데이터가 없어야 한다.
        Optional<Order> orderOptional = orderRepository.findById(order.getId());
        assertThat(orderOptional.isEmpty()).isTrue();
    }

    @Test
    void bizException() {
        //given
        Order order = new Order();
        order.setUsername("잔고부족");

        //when
        try {
            orderService.order(order);
            fail("잔고 부족 예외가 발생해야 합니다.");
        } catch (NotEnoughMoneyException e) {
            log.info("고객에게 잔고 부족을 알리고 별도의 계좌로 입금하도록 안내");
        }

        //then
        Order findOrder = orderRepository.findById(order.getId()).get();
        assertThat(findOrder.getPayStatus()).isEqualTo("대기");
    }
}

complete()

  • 사용자 이름을 정상으로 설정했다.
  • 프로세스 정상 수행

runtimeException()

  • 사용자 이름을 예외로 설정했다.
  • RuntimeException("시스템 예외")이 발생한다.
  • 런타임 예외로 롤백이 수행되었기 때문에 Order데이터가 비어 있는 것을 확인할 수 있다.

bizException()

  • 사용자 이름을 잔고부족으로 설정했다.
  • NotEnoughMoneyException("잔고가 부족합니다")이 발생한다.
  • 체크 예외로 커밋이 수행되었기 때문에 Order 데이터가 저장된다.
  • 대기 상태로 잘 저장 되었는지 확인 가능하다.

참고
김영한: 스프링 DB 2편 - 데이터 접근 활용 기술(인프런)
Github - https://github.com/b2b2004/Spring_DB

profile
Kwon Yongho
공책
이전 포스트

Spring DB - Querydsl, 데이터 접근 기술 활용 방안

다음 포스트

Spring DB - 스프링 트랜잭션 전파(1)

0개의 댓글