[Event] Spring Event 도입 시 트랜잭션 처리에 대한 고민

1. 서론

전 게시글에서 Spring Event로 의존성을 개선하는 법을 다뤄보았다. 하지만 한 트랜잭션 안에서 처리하던 것들이 흩어지면서 문제되는 부분도 있다. 이번엔 그 부분을 깊게 다뤄볼 생각이다.

 

Event를 적용하기 전 코드와 후 코드를 먼저 살펴보면 아래와 같다.

 

- 적용 전

@Service
@RequiredArgsConstructor
public class MemberService {

    private final AlarmService alarmService;
    private final AlimTalkService alimTalkService;

    public void register(String name) {
        // 회원가입 처리 로직
        System.out.println("회원 추가 완료");

        // 가입 축하 푸시 알림
        alarmService.send(name);

        // 카카오 알림톡 전송
        alimTalkService.send(name);
    }
}

 

위 로직은 핵심 로직과 부가적인 로직이 묶여있어 한눈에 보기 어려울 뿐더러 의존성이 높아 유지보수가 어렵다. 

위의 예제를 정리해보면 다음과 같은 비즈니스 로직을 표현하고 있다. 

 

• 회원가입 로직을 처리할 때
  • 가입 축하 푸시 알림
  • 카카오 알림톡 전송

 

- 적용 후

@Service
@RequiredArgsConstructor
@Transactional
public class MemberService {

    private final ApplicationEventPublisher publisher;

    public void register(String name) {
        // 회원가입 처리 로직
        System.out.println("회원 추가 완료");

        // 이벤트 등록
        publisher.publishEvent(new RegisteredEvent(name));
    }
}


@Component
@RequiredArgsConstructor
public class SmsEventHandler {

    private final AlarmService alarmService;
    private final AlimTalkService alimTalkService;

    @Async
    @EventListener
    public void sendFCM(RegisteredEvent event) throws InterruptedException {
        alarmService.send(event.getName());
    }
    
    @Async
    @EventListener
    public void sendAlimTalk(RegisteredEvent event) throws Exception {
        alimTalkService.send(event.getName());
    }
}


@Service
@RequiredArgsConstructor
@Transactional
public class AlarmService {
    private final AlarmRepository alarmRepository;
    public void send(String name) throws InterruptedException {
        alarmRepository.save(Alarm.builder().createdAt(LocalDateTime.now()).build());
        System.out.println(name + "에게 push 알림 발송");
    }
}


@Service
@Transactional
public class AlimTalkService {
    public void send(String name) throws Exception {
        Thread.sleep(3000); // 3초 sleep
        System.out.println(name + "에게 알림톡 발송");
        throw new Exception("에러 발생");
    }
}

 

위 코드에서 만약 회원이 저장되던 중 에러가 발생하면 알림을 보내던 로직들은 어떻게될까?? 

Async를 사용했고 다른 쓰레드에서 트랜잭션이 실행되기 때문에 서로 독립적으로 커밋된다. 따라서 회원가입은 되지 않았지만 알림은 전송되는 좋지 못한 상황이 발생한다. 

 

 

2. 문제가 되는 상황들

- 1. event를 비동기로 처리 & memberService 에서 예외가 발생할 경우

    @Transactional
    public void register(String name) throws Exception {
        // 회원가입 처리 로직
        memberRepository.save(Member.builder().name(name).build());

        // 이벤트 등록
        publisher.publishEvent(new RegisteredEvent(name));

        // 예외 발생
        throw new RuntimeException("member service 에러");
    }
}

 

memberService에서 예외가 터졌지만 비동기로 실행된 트랜잭션은 정상적으로 커밋됨

 

 

- 2. event를 동기로 처리 & 알람을 보내던 중 에러가 난 경우

@Service
@RequiredArgsConstructor
public class MemberService {

    private final ApplicationEventPublisher publisher;
    private final MemberRepository memberRepository;

    @Transactional
    public void register(String name) throws Exception {
        // 회원가입 처리 로직
        memberRepository.save(Member.builder().name(name).build());

        // 이벤트 등록
        publisher.publishEvent(new RegisteredEvent(name));
    }
}


@Service
@RequiredArgsConstructor
@Transactional
public class AlarmService {
    private final AlarmRepository alarmRepository;
    public void send(String name) throws InterruptedException {
        alarmRepository.save(Alarm.builder().createdAt(LocalDateTime.now()).build());
        System.out.println(name + "에게 push 알림 발송");
        // 예외 발생
        throw new RuntimeException("member service 에러");
    }
}

 

member 저장은 정상적으로 되었지만 부가적인 작업을 하던 중 에러가 난 것이다. 하지만 member 저장했던 부분까지 롤백되면서 쿼리가 나가지 않았다. 

 

 

이밖에도 많은 경우의 수가 있지만 이정도까지만 소개하겠다. 그럼 어떻게 해결할 수 있을까??

 

 

3. TransactionalEventListener

이러한 문제는 @TransactionEventListener로 해결할 수 있다. @TransactionEventListener는 Event의 실질적인 발생을 트랜잭션의 종료를 기준으로 삼는다.

 

- @TransactionalEventListener 옵션

@TransactionalEventListener을 이용하면 트랜잭션의 어떤 타이밍에 이벤트를 발생시킬 지 정할 수 있다. 옵션은 TransactionPhase을 사용하여 지정할 수 있고, 다음과 같은 옵션이 있다.

 

• AFTER_COMMIT (기본값) - 트랜잭션이 성공적으로 마무리(commit)됬을 때 이벤트 실행
• AFTER_ROLLBACK – 트랜잭션이 rollback 됬을 때 이벤트 실행
• AFTER_COMPLETION – 트랜잭션이 마무리 됐을 때(commit or rollback) 이벤트 실행
• BEFORE_COMMIT - 트랜잭션의 커밋 전에 이벤트 실행

 

- Handler 클래스에 AFTER_COMPLETION 옵션을 달고

- 알림을 발송하다 예외가 터지는 상황을 가정해보겠다.

 

@Component
@RequiredArgsConstructor
public class SmsEventHandler {

    private final AlarmService alarmService;
    private final AlimTalkService alimTalkService;

    //    @Async
    @TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)
    public void sendFCM(RegisteredEvent event) throws InterruptedException {
        alarmService.send(event.getName());
    }

    //    @Async
    @TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)
    public void sendAlimTalk(RegisteredEvent event) throws Exception {
        alimTalkService.send(event.getName());
    }
}

 

 

아까 위에서 문제되는 상황을 소개했는데, 그땐 member까지 저장되지 않았다.

하지만 이번엔 member는 잘 저장되고 예외가 터지는 모습을 볼 수 있다. 

 

 

AFTER_COMPLETION 주의 사항

TransactionalEventListener을 사용하여 이벤트 구조를 도입하여 간결한 코드 구조를 유지할 수 있어서 장점이 있지만, 트랜잭션과 함께 이벤트를 처리할 때 주의사항이 있다. phase 값이 AFTER_COMMIT 으로 정의해놓은 경우 리스너 코드 안에서 다시 트랜잭션을 처리하면 해당 트랜잭션은 커밋되지 않는 현상이 발생한다.

 

@Component
@RequiredArgsConstructor
public class SmsEventHandler {

    private final AlarmService alarmService;
    private final AlimTalkService alimTalkService;

    //    @Async
    @TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)
    public void sendFCM(RegisteredEvent event) throws InterruptedException {
        alarmService.send(event.getName());
    }

    //    @Async
    @TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)
    public void sendAlimTalk(RegisteredEvent event) throws Exception {
        alimTalkService.send(event.getName());
    }
}


@Service
@RequiredArgsConstructor
@Transactional
public class AlarmService {
    private final AlarmRepository alarmRepository;
    
    // 트랜잭션 commit 안 됨!!!!
    public void send(String name) throws InterruptedException {
        alarmRepository.save(Alarm.builder().createdAt(LocalDateTime.now()).build());
        System.out.println(name + "에게 push 알림 발송");
    }
}

 

 

이 현상에 대한 원인은 TransactionSynchronization 의 afterCommit 주석부분에 설명되어 있다.

/** * Invoked after transaction commit. Can perform further operations right * <i>after</i> the main transaction has <i>successfully</i> committed. * <p>Can e.g. commit further operations that are supposed to follow on a successful * commit of the main transaction, like confirmation messages or emails. * <p><b>NOTE:</b> The transaction will have been committed already, but the * transactional resources might still be active and accessible. As a consequence, * any data access code triggered at this point will still "participate" in the * original transaction, allowing to perform some cleanup (with no commit following * anymore!), unless it explicitly declares that it needs to run in a separate * transaction. Hence: <b>Use {@code PROPAGATION_REQUIRES_NEW} for any * transactional operation that is called from here.</b> * @throws RuntimeException in case of errors; will be <b>propagated to the caller</b> * (note: do not throw TransactionException subclasses here!) **/

 

요약하자면, 이전의 이벤트를 publish 하는 코드에서 트랜잭션이 이미 커밋 되었기 때문에 AFTER_COMMIT 이후에 새로운 트랜잭션을 수행하면 해당 데이터소스 상에서는 트랜잭션을 커밋하지 않는다는 것이다.

 

따라서 @Transactional 어노테이션을 적용한 코드에서 PROPAGATION_REQUIRES_NEW 옵션을 지정하지 않는다면 (매번 새로운 트랜잭션을 열어서 로직을 처리하라는 의미) 이벤트 리스너에서 트랜잭션에 의존한 로직을 실행했을 경우 이 트랜잭션은 커밋되지 않는다.

 

 

해결 방법 1)

위 문제를 해결하는 첫 번째 방법으로는 AFTER_COMMIT 이후에 동일한 데이터소스를 사용하지 않는 방법이 있다. 이를 위해서는 이벤트 리스너를 별도의 스레드에서 실행하는 방법이 있다. 바로 @Async 어노테이션을 추가하는 방법이다.

@Async
@TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)
public void sendAlimTalk(RegisteredEvent event) throws Exception {
    alimTalkService.send(event.getName());
}

 

위 코드는 이벤트 리스너 로직이 별도의 스레드에서 실행되어 트랜잭션이 커밋되기 때문에 의도한 결과를 얻을 수 있다. 

또한 문제가 되는 상황 1번째, 2번째 문제도 전부 해결할 수 있다.

 

해결 방법 2)

두번째 방법으론 @TransactionalEventListener 어노테이션에 추가로 @Transactional(propagation = Propagation.REQUIRES_NEW) 을 붙여주는 방법이다.

 

이렇게 하면 이벤트 리스너의 로직 안에서 실행되는 @Transactional 로직을 위한 새로운 트랜잭션이 이전의 트랜잭션과 구분되어 새롭게 시작한다. 따라서 이벤트를 발생시킨 트랜잭션과는 별도의 분리된 트랜잭션 안에서 이벤트 리스너 로직이 실행된다.

    @TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void sendAlimTalk(RegisteredEvent event) throws Exception {
        alimTalkService.send(event.getName());
    }