[Spring Boot] DB 트랜잭션을 가지는 API에서 리스트를 처리하면서 실패한 요소만 롤백하기

Spring Boot 의 Transaction 관리 

Spring Boot에서는 Transaction 관리를 위해 TransactionManager 인터페이스와 이를 확장한 다양한 종류의 인터페이스 및 구현체들을 제공한다. TransactionManager를 사용하는 일반적인 방법은 Transaction 단위의 메서드에 @Transactional 어노테이션을 적용하는 것인데, 어노테이션을 적용한 메서드가 호출되면 트랜잭션을 생성하고 메서드가 종료하면 commit, 예외가 발생하면 rollback한다.  

package org.springframework.transaction;

import org.springframework.lang.Nullable;

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

    void commit(TransactionStatus status) throws TransactionException;

    void rollback(TransactionStatus status) throws TransactionException;
}

 

[코드 1] Spring의 PlatformTransactionManager 

 

JDBC를 사용하면 JDBC 전용 TransactionManager 구현체에서 PlatformTransactionManager의 메서드를 구현해 트랜잭션을 생성, commit, rollback 하고 JPA를 사용하면 JPA 전용 구현체에서 트랜잭션을 생성, commit, rollback 한다. 그리고 두 구현체 모두 메서드가 시작하면서 Database와 Connection을 생성하고 메서드가 종료되면 Connection Pool 으로 반납(close)한다. 

 

public final TransactionStatus getTransaction(@Nullable TransactionDefinition definition) throws TransactionException {
    TransactionDefinition def = definition != null ? definition : TransactionDefinition.withDefaults();
    Object transaction = this.doGetTransaction();
    boolean debugEnabled = this.logger.isDebugEnabled();
    if (this.isExistingTransaction(transaction)) {
        return this.handleExistingTransaction(def, transaction, debugEnabled);
    } else if (def.getTimeout() < -1) {
        throw new InvalidTimeoutException("Invalid transaction timeout", def.getTimeout());
    } else if (def.getPropagationBehavior() == 2) {
        throw new IllegalTransactionStateException("No existing transaction found for transaction marked with propagation 'mandatory'");
    } else if (def.getPropagationBehavior() != 0 && def.getPropagationBehavior() != 3 && def.getPropagationBehavior() != 6) {
        if (def.getIsolationLevel() != -1 && this.logger.isWarnEnabled()) {
            this.logger.warn("Custom isolation level specified but no actual transaction initiated; isolation level will effectively be ignored: " + def);
        }

        boolean newSynchronization = this.getTransactionSynchronization() == 0;
        return this.prepareTransactionStatus(def, (Object)null, true, newSynchronization, debugEnabled, (Object)null);
    } else {
        SuspendedResourcesHolder suspendedResources = this.suspend((Object)null);
        if (debugEnabled) {
            Log var10000 = this.logger;
            String var10001 = def.getName();
            var10000.debug("Creating new transaction with name [" + var10001 + "]: " + def);
        }

        try {
            return this.startTransaction(def, transaction, false, debugEnabled, suspendedResources);
        } catch (Error | RuntimeException var7) {
            Throwable ex = var7;
            this.resume((Object)null, suspendedResources);
            throw ex;
        }
    }
}

 

[코드 2] AbstractPlatformTransactionManager.class 의 getTransaction 메서드

 

 

protected Object doGetTransaction() {
    DataSourceTransactionObject txObject = new DataSourceTransactionObject();
    txObject.setSavepointAllowed(this.isNestedTransactionAllowed());
    ConnectionHolder conHolder = (ConnectionHolder)TransactionSynchronizationManager.getResource(this.obtainDataSource());
    txObject.setConnectionHolder(conHolder, false);
    return txObject;
}

 

[코드 3] DataSourceTransactionManager.class의 doGetTransaction 메서드

 

 

protected Object doGetTransaction() {
    JpaTransactionObject txObject = new JpaTransactionObject();
    txObject.setSavepointAllowed(this.isNestedTransactionAllowed());
    EntityManagerHolder emHolder = (EntityManagerHolder)TransactionSynchronizationManager.getResource(this.obtainEntityManagerFactory());
    if (emHolder != null) {
        if (this.logger.isDebugEnabled()) {
            this.logger.debug("Found thread-bound EntityManager [" + emHolder.getEntityManager() + "] for JPA transaction");
        }

        txObject.setEntityManagerHolder(emHolder, false);
    }

    if (this.getDataSource() != null) {
        ConnectionHolder conHolder = (ConnectionHolder)TransactionSynchronizationManager.getResource(this.getDataSource());
        txObject.setConnectionHolder(conHolder);
    }

    return txObject;
}

 

[코드 4] JpaTransactionManager.class의 doGetTransaction 메서드

 

 

protected void doCleanupAfterCompletion(Object transaction) {
    DataSourceTransactionObject txObject = (DataSourceTransactionObject)transaction;
    if (txObject.isNewConnectionHolder()) {
        TransactionSynchronizationManager.unbindResource(this.obtainDataSource());
    }

    Connection con = txObject.getConnectionHolder().getConnection();

    try {
        if (txObject.isMustRestoreAutoCommit()) {
            con.setAutoCommit(true);
        }

        DataSourceUtils.resetConnectionAfterTransaction(con, txObject.getPreviousIsolationLevel(), txObject.isReadOnly());
    } catch (Throwable var5) {
        Throwable ex = var5;
        this.logger.debug("Could not reset JDBC Connection after transaction", ex);
    }

    if (txObject.isNewConnectionHolder()) {
        if (this.logger.isDebugEnabled()) {
            this.logger.debug("Releasing JDBC Connection [" + con + "] after transaction");
        }

        DataSourceUtils.releaseConnection(con, this.dataSource);
    }

    txObject.getConnectionHolder().clear();
}

 

[코드 5] DataSourceTransactionManager.class의 doCleanupAfterCompletion 메서드

 

 

protected void doCleanupAfterCompletion(Object transaction) {
    JpaTransactionObject txObject = (JpaTransactionObject)transaction;
    if (txObject.isNewEntityManagerHolder()) {
        TransactionSynchronizationManager.unbindResourceIfPossible(this.obtainEntityManagerFactory());
    }

    txObject.getEntityManagerHolder().clear();
    if (this.getDataSource() != null && txObject.hasConnectionHolder()) {
        TransactionSynchronizationManager.unbindResource(this.getDataSource());
        ConnectionHandle conHandle = txObject.getConnectionHolder().getConnectionHandle();
        if (conHandle != null) {
            try {
                this.getJpaDialect().releaseJdbcConnection(conHandle, txObject.getEntityManagerHolder().getEntityManager());
            } catch (Throwable var5) {
                Throwable ex = var5;
                this.logger.error("Failed to release JDBC connection after transaction", ex);
            }
        }
    }

    this.getJpaDialect().cleanupTransaction(txObject.getTransactionData());
    if (txObject.isNewEntityManagerHolder()) {
        EntityManager em = txObject.getEntityManagerHolder().getEntityManager();
        if (this.logger.isDebugEnabled()) {
            this.logger.debug("Closing JPA EntityManager [" + em + "] after transaction");
        }

        EntityManagerFactoryUtils.closeEntityManager(em);
    } else {
        this.logger.debug("Not closing pre-bound JPA EntityManager after transaction");
    }

}

 

[코드 6] JpaTransactionManager.class의 doCleanupAfterCompletion 메서드 

 

 

 

Spring AOP와 @Transactional의 프록시 객체 

@Transactional 어노테이션은 이상의 TransactionManager 객체들의 Transaction 처리를 정의하는 선언적 프로그래밍 방식이다. private 메서드에는 적용할 수 없고 @Transactional 어노테이션을 적용한 메서드는 다른 메서드 내에서 호출하면 정상적으로 동작하지 않는다. @Transacional 어노테이션을 메서드에 적용하면, 해당 메서드를 호출하는 경우에 AOP Proxy 객체가 생성되고 Transaction Advisor가 Transaction 생성, commit, rollback 작업을 수행한다. 그리고 Target 메서드를 호출하는 것도 AOP Proxy 객체이다. 그래서 @Transactional 어노테이션은 외부에서 접근이 가능한 메서드에만 적용할 수 있다. 그리고 원 객체가 Target 메서드를 호출하면 Transaction 처리가 안되기 때문에, 같은 객체 내의 다른 메서드 안에서 호출하면 안된다. 

 

 

실무 요구사항 : List를 처리하는 API에서 실패한 요소만 rollback하고 나머지 요소들에 대한 Transaction들을 커밋 

실무에서는 배치 어플리케이션에서 읽고 가공한 List 데이터를 API 호출로 처리하되, API 서버에서 List 요소들 중에 특정 요소가 실패하면 모든 List에 대한 작업을 rollback하지 않고 실패한 요소만 rollback해야 했다. 배치 어플리케이션에서 단일 데이터를 여러번 API 호출해서 처리할 수도 있지만, 네트워크 비용과 연산 비용이 낭비되고 결과적으로 처리 시간이 길어졌다. API 호출 횟수를 최소화하고 API 서버 내에서 필요한 트랜잭션 처리를 구현해야 했다. 

 

TransactionTemplate을 사용하지 않고 이미 사용 중인 @Transactional 어노테이션을 사용했다. @Transactional 어노테이션을 적용한 단일 데이터를 처리하는 메서드를 API 서버에서 여러번 호출하면서 실패한 단일 데이터에 대한 Transaction만 rollback하고 나머지 요소들에 대한 Transaction은 commit되도록 했다. @Transactional 어노테이션을 적용한 메서드를 동일한 객체의 다른 메서드 내에서 호출하면 트랜잭션 처리가 안될 것이기 때문에, 다른 객체에서 호출하는 방식으로 구현해야 했다. 그리고 호출한 메서드에서 예외가 발생해도 다른 요소들은 계속 처리될 수 있도록 내부에서 호출한 객체와 메서드에서 예외가 발생하면 로깅 처리하고 예외를 반환하지는 않도록 했다.  

 

/** 수기 송장 목록 등록 */
public void createOutboundInvoiceList(List<LogisticsFront.CreateOutboundInvoiceRequest> request
                                    , AccessUserInfo accessUserInfo) {
    for (LogisticsFront.CreateOutboundInvoiceRequest req : request) {
        try {
            logisticsService.createOutboundInvoice(req, accessUserInfo);
        } catch (Exception e) {
            log.warn("송장 등록 API 호출 결과 예외가 발생했습니다. :: {}", e.getMessage());
        }
    }
}

 

[코드 7] List<T> request를 전달받아 내부적으로 for문을 돌면서 Service 객체의 메서드를 호출하고 예외시 로깅 후 이어감 

 

@Override
@Transactional
public void createOutboundInvoice(CreateOutboundInvoiceRequest request
                                , AccessUserInfo accessUserInfo) {                            
	
    LogisticsDomain.CreateOutboundInvoiceCommand cmd = logisticsMapper.of(request);
    
    ...
    
    if (Objects.nonNull(outbound)) {

		...
        
        if (Objects.isNull(foundedOutboundInvoice)) {
        
        	...
        
        } else {
            throw new OrderException("이미 등록된 송장 번호입니다. 송장번호 : " + cmd.invoiceNumber());
        }
    } else {
        throw new NotFoundException("출고 정보를 찾을 수 없습니다. 출고번호 : " + cmd.outboundNumber());
    }
    
}

 

[코드 8] List Service 객체의 메서드에 @Transactional 어노테이션을 적용하고 rollback case에 대하여 예외를 던짐 

 

 

 

맺음말 

이상으로 Spring의 Transaction 관리 객체들을 살펴보고 @Transactional 어노테이션을 적용한 메서드의 동작 방식에 대해서 살펴본 후, 실무에서 요구하는 Transaction 처리를 구현한 사례에 대해서 소개했다. @Transactional 어노테이션을 사용하는 방법이  TransactionTemplate을 사용하는 방법보다 일반적면서 실무에서 사용하지도 않았기 때문에 TransactionTemplate 사용법은 추가 설명하지 않았다. 참고로, 배치 어플리케이션에서 List 데이터를 API 호출한 경우에, 데이터들 중 하나라도 예외가 발생하면 해당 배치 작업을 전부 rollback하는 것이 일반적이다. 실무에서는 특수한 사유로 그렇게 하지 않았다.