소개

스프링의 AOP를 통해 트랜잭션(@Transactional)을 다루다 보면 같은 작업을 진행하면서 이전 트랜잭션 상속받거나(REQUIRE), 새로운 트랜잭션을 열어서 처리해야하는(REQUIRE_NEW)일이 발생하게 되었습니다.

호출지점에서 트랜잭션을 선택적으로 사용할 수 있도록 하기 위한 트랜잭션 처리를 위한 monadic container type 을 구현해 보았습니다.

AOP를 이용한 트랜잭션

@Transactional
public UserEntity saveUser(String userName) {
   UserEntity userEntity = new UserEntity();
   userEntity.setUserName(userName);
   return userRepository.save(userEntity);
}

public void run() {
   saveUser("testUserName");
}

@Transactional 어노테이션을 사용하여 트랜잭션 처리를 하고 싶은 클래스, 혹은 메 서드에서 트랜잭션을 사용 할 수 있었습니다.

이를통해서 쉽고 가독성 좋은 코드를 짤 수 있었지만, 성능 튜닝이나 새로운 기능 추가 등의 상황에서 같은 서비스에서 DB 트랜잭션을 짧게 가져가기 위해서 분리하거나 다른방식의 failover를 수행하기 위해서 새로운 트랜잭션을 열어야하는 요구사항이 생기게 되었습니다.

이때 @Transactional(propagation = Propagation.REQUIRES_NEW)를 추가한 새로운 메소드를 추가 하는것과 같이 AOP만으로는 이러한 요구사항을 수행하는데 많은 어려움이 있었습니다.

함수형 접근

함수형 트랜잭션 사용하기

// AOP
/*@Transactional
public UserEntity saveUser(String userName) {
   UserEntity userEntity = new UserEntity();
   userEntity.setUserName(userName);
   return userRepository.save(userEntity);
}*/

public Transaction<UserEntity> saveUser(String userName) {
      return Transaction.create(() -> {
          UserEntity userEntity = new UserEntity();
          userEntity.setUserName(userName);
          return userRepository.save(userEntity);
      })
}

public void run() {
   // saveUser("testUserName"); AOP
   saveUser("testUserName")
			. execute(transactionManager, Propagation.REQUIRE); // 트랜잭션 매니저와 Propagation 설정
}

Transaction<T>가 호출되는 부분 execute 에서 트랜잭션 매니저와 Propagation을 지정해줌으로써 트랜잭션을 좀더 자유롭게 다룰 수 있게 되었습니다.

트랜잭션 Monadic Container 구조

public class Transaction<T> implements TransactionPublisher {
    private final Function<Void, T> action;

    private Transaction(Function<Void, T> action) {
        this.action = action;
    }

    public static <T> Transaction<T> create(Callable<T> callable) {
        return new Transaction<>(aVoid -> silentCallable(callable));
    }

    public static Transaction<Void> create(Runnable runnable) {
        return new Transaction<>(aVoid -> {
            runnable.run();
            return null;
        });
    }

    public <U> Transaction<U> map(Function<? super T, ? extends U> mapper) {
        return new Transaction<>(action.andThen(mapper));
    }

    public <U> Transaction<U> flatMap(Function<? super T, ? extends Transaction<U>> mapper) {
        return new Transaction<>(aVoid -> {
            Transaction<U> apply = action.andThen(mapper).apply(null);
            return apply.get();
        });
    }

    private T get() {
        return action.apply(null);
    }

    @Override
    public T execute(PlatformTransactionManager platformTransactionManager, Propagation propagation) {
        TransactionTemplate txTemplate = new TransactionTemplate(platformTransactionManager);

        txTemplate.setPropagationBehavior(propagation.value());
        return txTemplate.execute(status -> action.apply(null));
    }

    @SneakyThrows
    private static <T> T silentCallable(Callable<T> callable) {
        return callable.call();
    }
}

public interface TransactionPublisher<T> {
    T execute(PlatformTransactionManager platformTransactionManager, Propagation propagation);
}

트랜잭션 내부에서 실행될 코드를 Function<Void, T> action 으로 가지고 있고 실제 코드가 실행되는 시점인 Transaction#execute 에서 트랜잭션 매니저와 Propagation을 주입받도록 하였습니다.

flatMap 사용하기

public Transaction<UserEntity> saveUser(String userName) {
      return Transaction.create(() -> {
          UserEntity userEntity = new UserEntity();
          userEntity.setUserName(userName);
          return userRepository.save(userEntity);
      })
}

public void run() {
   // saveUser("testUserName"); AOP
   saveUser("testUserName")
			.flatMap(u -> saveUser("testUserName"))
			. execute(transactionManager, Propagation.REQUIRE); // 트랜잭션 매니저와 Propagation 설정
}

flatMap을 이용하여 Transaction<T> 를 연결함으로써 같은 트랜잭션에서 실행 할 수 있습니다.

종합

트랜잭션처리를 위한 monadic container를 만들어 보았습니다. 이를 통해서 호출되는 시점에 트랜잭션을 상속받거나, 새로운 트랜잭션을 오픈하는것을 선택적으로 사용 할 수 있게 되었습니다.

여전히 기본적으로는 좀더 익숙한 @Transactional을 이용한 트랜잭션 처리를 기본으로 사용하고 있지만 필요한 장소에 Transaction<T> 을 이용한 함수형 트랜잭션을 사용함으로써 명시적으로 표현할 필요가 있는곳을 좀더 깔끔하게 처리 할 수 있었습니다.

위 소스코드는 GitHub - namjug-kim/functional-transaction 를 통해서 보실 수 있습니다.

🧑‍💻 함수형으로 트랜잭션 처리하기

소개

AOP를 이용한 트랜잭션

함수형 접근

함수형 트랜잭션 사용하기

트랜잭션 Monadic Container 구조

flatMap 사용하기

종합