🧑‍💻 Spring에서 DDD Domain Event 사용하기

서론

SpringFramework은 이벤트를 사용하기 위한 ApplicationEventPublisher를 제공하고 있다. 이러한 ApplicationEventPublisher를 활용해서 DDD의 도메인 이벤트를 쉽게 사용 할 수 있는 여러가지 방법을 시도해보았고, 각 방법의 단점에 대해서 알아보고자 한다.

1. 명시적으로 이벤트 발생시키기

첫번째 방법은 Spring Framework의 ApplicationEventPublisher를 사용하는 방법 입니다. ApplicationService에서 도메인 로직을 실행하고 도메인 로직에 해당하는 DomainEvent를 직접 전달하는 방식입니다.

@Entity
class Match {
    @Id
    @GeneratedValue
    val id: Long? = null

    var homeScore: Int = 0
        private set

    var awayScore: Int = 0
        private set

    fun confirmMatchScore(homeScore: Int, awayScore: Int) {
        if (homeScore < 0 || awayScore < 0) {
            throw IllegalArgumentException("score value is negative.")
        }

        this.homeScore = homeScore
        this.awayScore = awayScore
    }
}

@Service
class ManualEventService(
    private val applicationEventPublisher: ApplicationEventPublisher,
    private val matchRepository: MatchRepository
) {
    @Transactional
    fun confirmMatchScore(matchId: Long, homeScore: Int, awayScore: Int) {
        val match = (matchRepository.findByIdOrNull(matchId)
            ?: throw IllegalArgumentException("match doesn't exists."))

        match.confirmMatchScore(homeScore, awayScore)
        // 명시적인 이벤트 발생
        applicationEventPublisher.publishEvent(MatchConfirmedEvent(matchId, homeScore, awayScore))
    }
}

별다른 설정 없이 도메인 로직 이후에 로직에 해당하는 Event를 서비스레이어에서 발생 시킬 수 있습니다. 코드에서도 알 수 있듯이, 실제 도메인 로직은 Entity 내부에서 발생하지만 도메인 이벤트는 서비스레이어에서 발행하기 때문에 코드의 응집도가 떨어지고 이러한 문맥을 사전에 알지 못하는 다른 개발자가 match#confirmMatchScore를 다른곳에서 사용하는 경우 도메인 이벤트 발행이 누락 될 가능성이 높아집니다.

2. Spring Framework @DomainEvents를 이용하여 이벤트 발생시키기

Spring Framework에서는 이러한 도메인 이벤트 발행을 Entity class에서 쉽게 할 수 있도록 @DomainEvents와 @AfterDomainEventPublication를 제공하고 있습니다.

@DomainEvents 어노테이션을 통해서 도메인 이벤트 목록을 넘기고 @AfterDomainEventPublication은 @DomainEvents로 도메인 이벤트를 전달할 이후에 호출됩니다.

직접 @DomainEvents와 @AfterDomainEventPublication 어노테이션을 사용한 abstract class를 구현해도 되고 Spring Data에서 제공하는 AbstractAggregateRoot를 사용해도 됩니다.

/**
 * Clears all domain events currently held. Usually invoked by the infrastructure in place in Spring Data
 * repositories.
 */
@AfterDomainEventPublication
protected void clearDomainEvents() {
  this.domainEvents.clear();
}

/**
 * All domain events currently captured by the aggregate.
 */
@DomainEvents
protected Collection<Object> domainEvents() {
  return Collections.unmodifiableList(domainEvents);
}

AbstractAggregateRoot를 사용하면 서비스레이어에서 발행하던 이벤트 로직을 제거하고 실제 도메인 로직에서 도메인 이벤트를 발행 할 수 있게 됩니다.

fun confirmMatchScore(homeScore: Int, awayScore: Int) {
    if (homeScore < 0 || awayScore < 0) {
        throw IllegalArgumentException("score value is negative.")
    }

    this.homeScore = homeScore
    this.awayScore = awayScore
    this.registerEvent(MatchConfirmedEvent(this.id ?: error("not persisted"), homeScore, awayScore))
}

2.1. @DomainEvents Under the Hood

@DomainEvents는 RepositoryProxyPostProcessor구현체인 EventPublishingRepositoryProxyPostProcessor를 통해 실행됩니다.

/*
 * (non-Javadoc)
 * @see org.aopalliance.intercept.MethodInterceptor#invoke(org.aopalliance.intercept.MethodInvocation)
 */
@Override
public Object invoke(@SuppressWarnings("null") MethodInvocation invocation) throws Throwable {

	Object[] arguments = invocation.getArguments();
	Object result = invocation.proceed();

	if (!invocation.getMethod().getName().startsWith("save")) {
		return result;
	}

	Object eventSource = arguments.length == 1 ? arguments[0] : result;

	eventMethod.publishEventsFrom(eventSource, publisher);

	return result;
}

EventPublishingRepositoryProxyPostProcessor는 RepositoryFactoryBeanSupport를 통해서 등록되며 위 코드와 같이 Spring Data Repository의 save~로 시작하는 메소드가 호출되었을때 도메인 이벤트를 발행하게 됩니다. Method Interceptor를 통해서 실행되기 때문에 Entity클래스에서 ApplicationEventPublisher bean을 가지고 있지 않더라도 사용이 가능하기때문에 도메인 로직에서 이벤트를 발행 할 수 있게 됩니다.

여기서 한가지 문제점이 생기게 되는데 도메인 이벤트가 Method Interceptor를 통해 발행되기 때문에 Repository의 save메소드가 호출되어야지만 이벤트 발행 로직이 실행되게 됩니다. JPA의 변경 감지(Dirty Checking)와 같이 save 메소드 호출 없이 변경동작이 가능하기때문에 이러한 문맥을 이어가지 않고 도메인 로직을 실행한 이후에 Repository#save를 호출하지 않으면 도메인 로직은 실행되지만 도메인 이벤트는 발행 되지 않는 문제가 발생하게 됩니다.

3. AOP를 이용한 도메인 이벤트 발행

위 1,2번의 단점을 보완하기 위해서 AOP를 이용한 도메인 이벤트 발행 방법이 많이 사용되고 있습니다.

1번의 서비스레이어에서 도메인 이벤트를 발행해 도메인 로직 실행과 도메인 이벤트 발행의 응집도가 떨어진다.
2번의 save를 명시적으로 호출해야지만 실행되기 때문에 도메인 로직이 변경감지로 완료되었을때 도메인 이벤트 발행이 누락되는 케이스가 발행한다.

ApplicationEventPublisher를 ThreadLocal에 보관하는 컨텍스트 클래스

public class Events {
    private static ThreadLocal<ApplicationEventPublisher> publisherLocal = new ThreadLocal<>();

    public static void raise(DomainEvent event) {
        if (event == null) return;

        if (publisherLocal.get() != null) {
            publisherLocal.get().publishEvent(event);
        }
    }

    static void setPublisher(ApplicationEventPublisher publisher) {
        publisherLocal.set(publisher);
    }

    static void reset() {
        publisherLocal.remove();
    }
}

@Aspect
@Component
public class EventPublisherAspect implements ApplicationEventPublisherAware {
    private ApplicationEventPublisher publisher;
    private ThreadLocal<Boolean> appliedLocal = new ThreadLocal<>();

    @Around("@annotation(org.springframework.transaction.annotation.Transactional)")
    public Object handleEvent(ProceedingJoinPoint joinPoint) throws Throwable {
        Boolean appliedValue = appliedLocal.get();
        boolean nested = false;
        
        if (appliedValue != null && appliedValue) {
            nested = true;
        } else {
            nested = false;
            appliedLocal.set(Boolean.TRUE);
        }
        
        if (!nested) Events.setPublisher(publisher);
        
        try {
            return joinPoint.proceed();
        } finally {
            if (!nested) {
                Events.reset();
                appliedLocal.remove();
            }
        }
    }

    @Override
    public void setApplicationEventPublisher(ApplicationEventPublisher eventPublisher) {
        this.publisher = eventPublisher;
    }
}

도메인 로직은 ApplicationService(@Service + @Transactional)에서 실행되기 때문에 @Transactional pointcut을 통해서 서비스레이어 메소드 호출 시점에 ThreadLocal을 통해서 Spring의 ApplicationEventPublisher을 넘겨줘서 Entity에서 Events#raise를 호출함으로써 도메인 이벤트를 발행 할 수 있게 된다. e

3.1. AOP와 ThreadLocal을 이용한 이벤트 발행의 문제점

실제 프로덕션에서 사용했을때 1번과 2번의 단점을 보완하면서 편하게 사용 할 수 있는 좋은 방법 이었다. 하지만 특이케이스가 하나둘 발생하면서 한가지 이슈가 있었는데 Events#raise를 통해서 즉시 이벤트가 발행되다 보니 해당 Entity가 Persisted된 Entity가 아니더라도 이벤트가 발행되는 이슈가 발생하게 되었다. 개인적인 생각에 Spring Data에서 제공하는 @DomainEvents가 이런 케이스때문에 save를 명시적으로 호출하는 방법으로 Persisted된 Entity임을 보장하는것 같았다. 하지만 2번의 단점이 너무 커서 실 사용에는 위험이 있었기때문에 3번의 아이디어에 2가지 아이디어를 더했다.

Hibernate Session에서 관리중인 Entity는 도메인 이벤트를 즉시 발행한다.
Hibernate Session에서 관리중이지 않은 Entity에서 발행된 이벤트는 Queue에 저장해 두었다가 save 호출 시점에 이벤트를 발행한다.

스치는 생각)
일반적인 케이스에서 PK Auto Creation을 사용한다면 ID가 null인경우로 체크해도 무방 할 것 같다.

4. Session확인을 적용한 AOP

아이디어는 3번의 아이디어와 거의 동일하며 몇가지 아이디어를 더하였다.

object Events {
    private val publisherLocal = ThreadLocal<ApplicationEventPublisher>()
    private val entityManagerLocal = ThreadLocal<EntityManager>()
    private val publishedEventLocal = ThreadLocal<HashSet<UUID>>()

    /**
     * session 에서 관리중이지 않은 Entity에서 발생한 이벤트를 담아둔다.
     */
    private val waitingEventQueue = ThreadLocal<MutableMap<Int, Queue<DomainEventHolder<*>>>>()
}

EntityManager를 넘겨주어 Session에서 관리중인 상태를 확인한다.
publishedEventLocal(HashSet)을 통해서 이벤트가 중복 발행되지 않도록 한다.
waitingEventQueue에 Session에서 관리중이지 않은 Entity에서 발행된 도메인 이벤트를 저장하고 Repository#save~ 호출시점에 발행한다.

/**
 * session에서 관리중인 [DomainEntity]에서 발생한 [DomainEvent] 는 즉시 발행한다.
 * session에서 관리중이지 않은 [DomainEntity]에서 발생한 [DomainEvent]는 [waitingEventQueue]에 담아두었다가 [DomainEntity]가 save될때 발행한다.
 */
fun <T> publish(entity: DomainEntity<T>, event: DomainEvent<T>) {
    if (entityManagerLocal.get().contains(entity)) {
        this.publishEvent(entity, event)
    } else {
        val entityDomainEventQueue = waitingEventQueue.get()
        val entityClassHashCode = System.identityHashCode(entity)
        val queue = entityDomainEventQueue.computeIfAbsent(entityClassHashCode) { LinkedList() }
        queue.add(DomainEventHolder(entity, event))
    }
}

동작을 하나씩 살펴보면 Events.publish(/*Domain*/, /*DomainEvent*/)도메인 이벤트 발행시 도메인과 도메인 이벤트를 모두 넘겨받고

도메인이 세션에서 관리중인지 확인한다.
세션에서 관리중이라면 즉시 이벤트를 발행한다.
세션에서 관리중이 아니라면 대기 큐에 추가한다.

여기서 조금 독특하게 도메인 이벤트를 저장하기 위해서 val entityClassHashCode = System.identityHashCode(entity)를 key값으로 사용했는데 도메인 클래스는 일반적으로 PK를 통한 equals를 구현하는데 세션에서 관리중이지 않은 Entity의 경우 PK가 존재하지 않기때문에 key값을 위한 hashCode를 별도로 생성하였다.

/**
 * session에서 관리되지 않는 상태의 Entity에서 생성되었던 [DomainEvent]를 발행한다.
 */
fun publishWaitingQueue(entityClass: Any) {
    if (waitingEventQueue.get() == null) {
        return
    }

    val entityDomainEventQueue = waitingEventQueue.get()
    val entityClassHashCode = System.identityHashCode(entityClass)
    entityDomainEventQueue[entityClassHashCode]?.pollAll {
        val domainEventHolder = it as DomainEventHolder<Any>
        domainEventHolder.domainEvent.aggregateRootId = domainEventHolder.domainEntity.getId()
        this.publishEvent(domainEventHolder.domainEntity, domainEventHolder.domainEvent)
    }
}

대기큐에 저장된 발행된 이벤트를 발행시키기 위해서 2번의 RepositoryProxyPostProcessor를 사용하였다.

class CustomJpaRepositoryFactoryBean<T : Repository<S, ID>, S, ID>(repositoryInterface: Class<out T>) : JpaRepositoryFactoryBean<T, S, ID>(repositoryInterface) {
    override fun doCreateRepositoryFactory(): RepositoryFactorySupport {
        val repositoryFactorySupport = super.doCreateRepositoryFactory()
        repositoryFactorySupport.addRepositoryProxyPostProcessor { factory: ProxyFactory, _: RepositoryInformation? ->
            factory.addAdvice(MethodInterceptor { invocation: MethodInvocation ->
                val arguments = invocation.arguments
                val result = invocation.proceed()
                if (!invocation.method.name.startsWith("save")) {
                    return@MethodInterceptor result
                }

                val eventSource = if (arguments.size == 1) arguments[0] else result
                if (eventSource is List<*>) {
                    eventSource.asSequence()
                        .filterNotNull()
                        .forEach { publishWaitingQueue(it) }
                } else {
                    publishWaitingQueue(eventSource)
                }
                result
            })
        }
        return repositoryFactorySupport
    }
}

Repository 생성 커스터마이징을 위해서 JpaRepositoryFactoryBean를 상속받아 doCreateRepositoryFactory메소드에서 Repository#save가 호출되는 시점에 Events.publishWaitingQueue를 실행하였다.

총평

서비스레이어에서 도메인 이벤트를 발생시키는것부터 AOP를 이용하는 방법까지 총 4가지 방법을 사용해 보았다. 처음에는 Spring Data에서 제공되는 2번의 방법(Repository#save를 명시적으로 호출)이 잘 납득이 되지 않았는데 3,4번의 과정을 거치면서 여러가지 케이스를 마주하다 보니 왜 저렇게 제공 되었는지 납득이 되었다. 다음부터는 Spring Framework(꼭 Spring이 아니더라도 널리 사용되는 오픈소스 프레임워크)이 제공하는 방법에 대해서 조금더 깊게 이해하고 접근하는 시도가 필요하겠다 라는 생각을 하게 되었다. 개인적으로 1번을 제외한 2,3,4번의 방식은 각각의 장,단점이 존재하기때문에 프로젝트를 진행하는 팀원들에 성향에 맞춰서 취사 선택을 하면 될 것 같다.

reference

https://www.baeldung.com/spring-data-ddd
https://supawer0728.github.io/2018/03/24/spring-event/
https://javacan.tistory.com/entry/Handle-DomainEvent-with-Spring-ApplicationEventPublisher-EventListener-TransactionalEventListener