[스프링 DB 2편] #9. 스프링 트랜잭션 이해(3)

[YONGHYNG]

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

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

package hello.springtx.exception;

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.*;

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

**1. runtimeException() 실행 - 런타임 예외 **

//런타임 예외 발생: 롤백
@Transactional
public void runtimeException() {
           log.info("call runtimeException");
           throw new RuntimeException();
}

• RuntimeException이 발생하므로 트랜잭션이 롤백 됨

실행 결과

Getting transaction for [...RollbackService.runtimeException]
call runtimeException
Completing transaction for [...RollbackService.runtimeException] after 
exception: RuntimeException
Initiating transaction rollback
Rolling back JPA transaction on EntityManager

checkedException() 실행 - 체크 예외

//체크 예외 발생: 커밋
@Transactional
public void checkedException() throws MyException {
         log.info("call checkedException");
         throw new MyException();
}

실행 결과

Getting transaction for [...RollbackService.checkedException]
call checkedException
Completing transaction for [...RollbackService.checkedException] after 
exception: MyException
Initiating transaction commit
Committing JPA transaction on EntityManager

rollbackFor

• 이 옵션을 사용하면 기본 정책에 추가로 어떤 예외가 발생할 때 롤백할 지 지정할 수 있음
  @Transactional(rollbackFor = Exception.class)
• 예를ㄹ 들어서 이렇게 지정하면 체크 예외인 Exception이 발생해도 커밋 대신 롤백 됨(자식 타입도 롤백)

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

//체크 예외 rollbackFor 지정: 롤백
@Transactional(rollbackFor = MyException.class)
public void rollbackFor() throws MyException {
         log.info("call rollbackFor");
         throw new MyException();
}

• 기본 정책과 무관하게 특정 예외를 강제로 롤백하고 싶으면 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

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

• 스프링은 왜 체크 예외는 커밋하고, 언체크(런타임) 예외는 롤백할까?
• 스프링 기본적으로 체크 예외는 비즈니스 의미가 있을 때 사용, 런타임(언체크) 예외는 복구 불가능한 예외로 가정
• 체크 예외 : 비즈니스 의미가 있을 때 사용
• 언체크 예외 복구 불가능한 예외

비즈니스 요구사항

주문을 하는데 상황에 따라 다음과 같이 조치

• 1. 정상 : 주문시 결제를 성공하면 주문 데이터를 저장, 결제 상태로 완료 처리
• 2. 시스템 예외 : 주문시 내부에 복구 불가능한 예외가 발생하면 전체 데이터를 롤백함
• 3. 비즈니스 예외 : 주문시 결제 잔고가 부족하면 주문 데이터 저장, 결제 상태를 대기로 처리
• => 위와 같은 경우 고객에게 잔고 부족을 알리고 별도의 계좌로 입금 안내 진행

NotEnoughMoneyException

package hello.springtx.order;

// 사용자 정의 예외 (체크 예외)
public class NotEnoughMoneyException extends Exception {

    // 생성자에서 메시지를 받아 부모 클래스의 생성자에 전달
    public NotEnoughMoneyException(String message) {
        super(message);
    }
}

• 결제 잔고가 부족하면 발생하는 비즈니스 예외, Exception을 상속 받아 체크 예외가 됨

**Order **

package hello.springtx.order;

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

@Entity // JPA 엔티티 지정
@Table(name = "orders") // 테이블명을 orders로 지정
@Getter @Setter // Lombok을 사용해 getter, setter 자동 생성
public class Order {

    @Id // 기본 키 (Primary Key)
    @GeneratedValue // 자동 증가 값 사용
    private Long id;

    private String username; // 주문자 이름 (특수 값: 정상, 예외, 잔고부족 가능)
    private String payStatus; // 결제 상태 (대기, 완료 등)
}

• JPA를 사용하는 Order 엔티티
• 예제를 단순하게 하기 위해 @Getter, @Setter 사용, 참고로 실무에서 엔티티에 @Setter를 남발해서 불필요한 변경 포인트를 노출하는 것은 좋지 않음
• 주의! @table(name = "orders")라고 했음, 테이블 이름을 지정하지 않으면 테이블 이름이 클래스 이름인 order가 됨, order는 디비 예약어(order by)여서 사용 불가, 그래서 orders라는 테이블 이름을 지정함

OrderRepository

package hello.springtx.order;

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

// JPA를 이용한 Order 엔티티의 Repository 인터페이스
public interface OrderRepository extends JpaRepository<Order, Long> {
}

• 스프링 데이터 JPA를 사용

OrderService

package hello.springtx.order;

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

@Slf4j // 로그를 위한 Lombok 어노테이션
@Service // 스프링 서비스 빈 등록
@RequiredArgsConstructor // final 필드를 자동으로 생성자 주입
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("결제 프로세스 완료");
    }
}

• 1. 기본 : payStatus를 완료 상태로 처리하고 정상 처리 됨
• 2. 예외 : RuntimeException("시스템, 예외") 런타임 예외가 발생한다
• 3. 잔고부족
• 3-1. payStatus를 대기 상태로 처리
• 3-2. NotEnoughMoneyException("잔고가 부족합니다") 체크 예외가 발생
• 3-3. 잔고 부족은 payStatus 를 대기 상태로 두고, 체크 예외가 발생하지만, order 데이터는 커밋되기
  를 기대

OrderServiceTest

package hello.springtx.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.*;

@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()

• 사용자 이름을 정상으로 설정, 모든 프로세스가 정상 수행
• 다음을 통해서 데이터가 완료 상태로 저장 되었는지 검증
• assertThat(findOrder.getPayStatus()).isEqualTo("완료");

runtimeException()

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

bizException()

• 사용자 이름을 잔고부족으로 설정
• NotEnoughMoneyException("잔고가 부족합니다") 이 발
• 체크 에외로 커밋이 수행, Order 데이터가 저장
• assertThat(findOrder.getPayStatus()).isEqualTo("대기"); 검증 진행

정리

• NotEnoughMoneyException은 시스템에 문제가 발생한 것이 아니라, 비즈니스 문제 상황을 예외를 통해 알려줌
• 마치 예외가 리턴 값 처럼 사용, 따라서 이 경우에는 트랜잭션을 커밋하는 것이 맞음
• 이 경우 롤백하면 생성한 Order 자체가 사라짐, 그러면 고객에게 잔고 부족을 알리고 별도의 계좌로 입금하도록 안내해 줌 주문(Order) 자체가 사라지기 때문에 문제가 됨
• 그런데 비즈니스 상황에 따라 체크 에외의 경우 트랜잭션을 커밋하지 않고, 롤백하고 싶을 수 있음, 이때는 follbackFor 옵션을 사용하면 됨
• 런타임 예외는 항상 롤백 함, 체크 예외의 경우 rollbackFor 옵션을 사용해서 비즈니스 상황에 따라 커밋과 롤백을 선택하면 됨