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

[YONGHYNG]

트랜잭션

JDBC 트랜잭션 코드 VS 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 기술로 변경하면 트랜잭션 사용 코드도 모두 변경해야 함
• 스프링은 이런 문제를 해결하기 위해 트랜잭션 추상화 제공
• 트랜잭션을 사용하는 입장에서는 스프링 트랜잭션 추상화를 통해 툴을 동일한 방식으로 사용할 수 있게 됨
• 스프링은 PlatformTransactionManager라는 인터페이스를 통해 트랜잭션을 추상화

PlatformTransactionManager 인터페이스

package org.springframework.transaction;

public interface PlatformTransactionManager extends TransactionManager {
    TransactionStatus getTransaction(@Nullable TransactionDefinition definition)
            throws TransactionException;

    void commit(TransactionStatus status) throws TransactionException;

    void rollback(TransactionStatus status) throws TransactionException;
}

• 트랜잭션은 트랜잭션 시작(획득), 커밋, 롤백으로 단순하게 추상화 가능

• 스프링은 트랜잭션을 추상화해서 제공할 뿐 아니라, 실무에서 주로 사용하는 데이터 접근 기술에 대한 트랜젝션 매니저의 구현체도 제공
• 우리는 필요한 구현체를 스프링 빈으로 등록하고 주입, 사용하기만 하면 됨
• 추가로, 스프링 부트는 어떤 데이터 접근 기술을 사용하는지를 자동으로 인식, 적절한 트랜잭션 매니저를 선택해서 스프링 빈으로 등록해주기 때문에 트랜잭션 매니저를 선택하고 등록하는 과정도 생략 가능
• EX) DataSourceTransactionManager(JdbcTransactionManager)를 스프링 빈 등록,
  JPA를 사용하면 JpaTransactionManager를 스프링 빈으로 등록해 줌

스프링 트랜잭션 사용 방식

• PlatformTransactionManager를 사용하는 방법은 크게 2가지

선언적 트랜잭션 관리(Declarative Transaction Management)

• @transactional 애노테이션 하나만 선언해서 매우 편리하게 트랜잭션을 적용하는 것을 선언적 트랜잭션 관리
• 선언적 트랜잭션 관리는 과거 XML에 설정
• 이름 그대로 해당 로직에 트랜잭션을 적용하겠다 라고 어딘가에 선언하기만 하면 트랜잭션이 적용

프로그래밍 방식의 트랜잭션 관리(programmatic transaction management)

• 트랜잭션 매니저 또는 트랜잭션 템플릿 등을 사용, 트랜잭션 관련 코드를 직접 장성하는 것을 프로그래밍 방식의 트랜잭션

선언적 트랜잭션과 AOP

• @transactional을 통한 선언적 트랜잭션 관리 방식을 사용하게 되면 기본적으로 프록시 방식의
  AOP가 적용

• 트랜잭션을 처리하기 위한 프록시를 도입하기 전에는 서비스의 로직에서 트랜잭션을 직접 시작

서비스 계층의 트랜잭션 사용 코드 예시

// 트랜잭션 시작
TransactionStatus status = transactionManager.getTransaction(new DefaultTransactionDefinition());
try {
    // 비즈니스 로직
    bizLogic(fromId, toId, money);
    transactionManager.commit(status); // 성공 시 커밋
} catch (Exception e) {
    transactionManager.rollback(status); // 실패 시 롤백
    throw new IllegalStateException(e);
}

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

트랜잭션 프록시 코드 예시

public class TransactionProxy {
    private MemberService target;
    private PlatformTransactionManager transactionManager;

    public TransactionProxy(MemberService target, PlatformTransactionManager transactionManager) {
        this.target = target;
        this.transactionManager = transactionManager;
    }

    public void logic() {
        // 트랜잭션 시작
        TransactionStatus status = transactionManager.getTransaction(new DefaultTransactionDefinition());
        try {
            // 실제 대상 호출
            target.logic();
            transactionManager.commit(status); // 성공 시 커밋
        } catch (Exception e) {
            transactionManager.rollback(status); // 실패 시 롤백
            throw new IllegalStateException(e);
        }
    }
}

트랜잭션 프록시 적용 후 서비스 코드 예시

public class Service {
                 public void logic() {
                 //트랜잭션 관련 코드 제거, 순수 비즈니스 로직만 남음
                 bizLogic(fromId, toId, money);
         }
}

• 프록시 도입 전 : 서비스에 비즈니스 로직과 트랜잭션 처리 로직이 함께 섞임
• 프록시 도입 후 : 트랜잭션 프록시가 트랜잭션 처리 로직 모두 가져감, 그리고 트랜잭션을 시작한 후에 실제 서비스를 대신 호출, 트랜잭션 프록시 덕분에 서비스 계층에 순수 비즈니스 로직만 있음

프록시 도입 후 전체 과정

• 트랜잭션은 커넥션에 con.setAutocommit(false)를 지정하면서 시작
• 같은 트랜잭션을 유지하려면 같은 디비 커넥션을 사용해야 함
• 이것을 위해 스프링 내부에서, 트랜잭션 동기화 매니저 사용
• JdbcTemplate을 포함한 대부분의 데이터 접근 기술들은 트랜잭션을 유지하기 위해 내부에서 트
  랜잭션 동기화 매니저를 통해 리소스<커넥션>를 동기화 함

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

• 스프링은 트랜잭션 AOP를 처리하기 위한 모든 기능 제공, 스프링 부트를 사용하면 트랜잭션 AOP를 처리하기 위해 필요한 스프링 빈들도 자동으로 등록
• 개발자는 트랜잭션 처리가 필요한 곳에 @transactional 매노테이션만 붙이면 됨, 스프링의 트랜잭션 AOP는 이 애노테이션을 인식, 트랜잭션을 처리하는 프록시를 적용해줌

@transactional
org.springframework.transaction.annotation.Transactional

트랜잭션 적용 확인

• 선언적 트랜잭션 방식을 사용하면 단순히 애노테이션 하나로 트랜잭션 적용 가능, 이 기능은 트랜잭션 관련 코드가 눈에 보이지 않고, AOP를 기반으로 동작, 실제 트랜잭션이 적용되고 있는지 아닌지 확인이 어려움

package hello.springtx.apply;

import lombok.extern.slf4j.Slf4j;
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.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.support.TransactionSynchronizationManager;

/**
 * 트랜잭션 적용 테스트 클래스
 * - 트랜잭션 프록시가 적용되는지 확인
 * - 트랜잭션이 실제 활성화되는지 확인
 */
@Slf4j
@SpringBootTest
public class TxBasicTest {

    @Autowired
    BasicService basicService; // 테스트 대상 빈

    /**
     * AOP 프록시 확인 테스트
     * - Spring이 @Transactional이 적용된 Bean을 프록시 객체로 감싸는지 확인
     * - AopUtils.isAopProxy()를 사용하여 프록시 여부를 검증
     */
    @Test
    void proxyCheck() {
        // 예상 결과: "BasicService$$EnhancerBySpringCGLIB..."
        log.info("aop class={}", basicService.getClass());
        assertThat(AopUtils.isAopProxy(basicService)).isTrue();
    }

    /**
     * 트랜잭션 활성화 여부 확인 테스트
     * - @Transactional 적용 메서드(tx)와 일반 메서드(nonTx)의 차이를 확인
     */
    @Test
    void txTest() {
        basicService.tx();    // 트랜잭션이 활성화됨
        basicService.nonTx(); // 트랜잭션이 활성화되지 않음
    }

    /**
     * 테스트 환경에서 사용할 Bean 등록 클래스
     */
    @TestConfiguration
    static class TxApplyBasicConfig {
        @Bean
        BasicService basicService() {
            return new BasicService();
        }
    }

    /**
     * 트랜잭션이 적용된 서비스 클래스
     */
    @Slf4j
    static class BasicService {

        /**
         * @Transactional이 적용된 메서드
         * - 트랜잭션이 활성화되어야 함
         */
        @Transactional
        public void tx() {
            log.info("call tx");
            boolean txActive = TransactionSynchronizationManager.isActualTransactionActive();
            log.info("tx active={}", txActive);
        }

        /**
         * @Transactional이 적용되지 않은 일반 메서드
         * - 트랜잭션이 활성화되지 않아야 함
         */
        public void nonTx() {
            log.info("call nonTx");
            boolean txActive = TransactionSynchronizationManager.isActualTransactionActive();
            log.info("tx active={}", txActive);
        }
    }
}

예상 로그 출력

proxyCheck() - 실행

• AopUtils.isAopProxy() : 선언적 트랜잭션 방식에서 스프링 트랜잭션은 AOP 기반 동작
• @transactional을 메서드나 클래스에 붙이면 해당 객체는 트랜잭션 AOP 적용의 대상이 됨,
  결과적으로 실제 객체 대신에 트랜잭션을 처리해주는 프록시 객체가 스프링 빈에 등록 됨, 그리고 주입을 받을 때도 실제 객체 대신에 프록시 객체가 주입 됨

스프링 컨테이너에 트랜잭션 프록시 등록

• @transactional 애노테이션이 특정 클래스나 메서드에 하나라도 있으면 트랜잭션 AOP는 프록시를 만들어서 스프링 컨테이너에 등록
• 실제 basicService 객체 대신에 프록시인 basicService$$CGLIB를 스프링 빈에 등록, 그리고 프록시는 내부에 실제 basicService 참조
• 핵심은 실제 객체 대신에 프록시가 스프링 컨테이너에 등록 되었다는 점
• 클라이언트인 txBasicTest 는 스프링 컨테이너에 @Autowired BasicService basicService 의존관계 주입을 요청, 스프링 컨테이너에는 실제 객체 대신에 프록시가 스프링 빈으로 등록되어 있기 때문에 프록시 주입
• 프록시는 BasicService를 상속해서 만들어지기 때문에 다형성을 활용, 따라서 BasicService
  대신에 프록시인 BasicService$$CGLIB 를 주입

트랜잭션 프록시 동작 방식

• 클라이언트가 주입 받은 basicService$$CGLIB는 트랜잭션을 적용하는 프록시

로그 추가

• 위 로그를 추가하면 트랜잭션 프록시가 호출하는 트랜잭션의 시작과 종료를 명확하게 로그로 확인 가능

basicService.tx() 호출

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

basicService.nonTx() 호출

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

TransactionSynchronizationManager.isActualTransactionActive()

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

실행 결과

• 로그를 통해 tx() 호출시에는 tx active-true를 통해 트랜잭션이 적용된 것을 확인 가능
• TransactionInterceptro 로그를 통해 트랜잭션 프록시가 트랜잭션을 시작하고 완료한 내용을 확인 가능
• nonTx() 호출시에는 tx active=false 를 통해 트랜잭션이 없는 것을 확인

트랜잭션 적용 위치

• 스프링에서 우선순위는 항상 더 구체적이고 자세한 것이 높은 우선순위를 가짐
• ex) 메서드의 클래스에 애노테이션을 붙일 수 있다면 더 구체적인 메서드가 더 높은 우선순위를 가짐

package hello.springtx.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() { // 별도 설정이 없으므로 기본적으로 readOnly = true 적용
            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. 우선순위 규칙 : 트랜잭션을 사용할 떄는 다양한 옵션 사용 가능

• 1-1. LevelService 의 타입에 @transactional(readOnly = true) 이 붙음

• 1-2. write() : 해당 메서드에 @transactional(readOnly = false) 이 붙음

• 1-2-1. 이렇게 되면 타입에 있는 @transactional(readOnly = true) 와 해당 메서드에 있는
  @transactional(readOnly = false) 둘 중 하나를 적용

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

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

• 2-1. read() : 해당 메서드에 @transactional이 없다. 이 경우 더 상위인 클래스 확인

• 2-1-1. 클래스에 @transactional(readOnly = true) 적용, 따라서 트랜잭션이 적용되고 readOnly = true 옵션을 사용하게 됨

TransactionSynchronizationManager.isCurrentTransactionReadOnly

• 현재 트랜잭션에 적용된 readOnly 옵션의 값을 반환

실행 결과

• write()에서는 tx readOnly=false : 읽기 쓰기 트랜잭션 적용, readOnly 가 아님
• read() 에서는 tx readOnly=true : 읽기 전용 트랜잭션 옵션인 readOnly 가 적용