DDD 아키텍처에 Event Driven Architecture 도입하기

@Transactional
public PairTokenResponse login(KakaoSocialLoginCommand command) {
    SocialUserProfileResult profile = loadKakaoUserProfilePort.load(command.authorizationCode());
    SocialAccount socialAccount = querySocialAccountService.findExistingSocialAccount(command.provider(), Long.valueOf(profile.providerId()))
                    .orElse(null);
 
    MemberAccount memberAccount;
    if (socialAccount != null) {
        // [Case A] 기존 가입자: 안전하게 기존 객체의 필드 접근
        memberAccount = queryMemberAccountService.findById(socialAccount.getMemberAccountId());
    } else {
        // [Case B] 신규 가입자: 새로운 객체 생성
        // B-1. 인증 객체 생성
        memberAccount = MemberAccount.create(profile.email(), MemberRole.USER);
        commandMemberAccountService.save(memberAccount);
 
        // B-2. 소셜 계정 객체 생성
        SocialUserProfileInfo socialUserProfileInfo = SocialUserProfileInfo.create(
            profile.providerId(), 
            profile.connectedAt(), 
            profile.emailAgreed(), 
            profile.profileNicknameAgreed(),
            profile.profileImageUrl(),
            profile.profileThumbnailImageUrl()
        );
        SocialAccount createSocialAccount = SocialAccount.create(memberAccount.getId(), socialUserProfileInfo);
        commandSocialAccountService.save(createSocialAccount);
        
        // B-3. 사용자 프로필 객체 생성
        UserProfileInfo userProfileInfo = UserProfileInfo.create(profile.nickname());
        UserProfile userProfile = UserProfile.create(memberAccount.getId(), userProfileInfo);
        commandUserProfileService.save(userProfile);
 
        // B-4. 이메일로 회원가입 축하 메시지 발송
        messageService.sendWelcomeEmail(memberAccount.getEmail());
    }
 
    TokenClaimsRequest claimsRequest = commandTokenService.createTokenClaimsRequest(memberAccount.getId(), memberAccount.getEmail(), memberAccount.getRole());
    return commandTokenService.issueTokenPair(claimsRequest);
}

// account.domain.event.SocialAccountLinkRequestedEvent.java
public record SocialAccountLinkRequestedEvent(
        Long memberId,
        OAuth2Provider provider,
        String providerId,
        Instant socialConnectedAt,
        boolean socialEmailAgreed,
        boolean socialNicknameAgreed
) {
}
 
// profile.domain.event.UserProfileCreatedEvent.java
public record UserProfileCreatedEvent(
        Long memberId,
        String nickname
) {
}
 
// notification.domain.event.WelcomeEmailSentEvent.java
public record WelcomeEmailSentEvent(
        Long memberId,
        String email
) {
}

// account.application.event.SocialAccountEventHandler.java
@EventListener
public void handleSocialAccountCreation(SocialAccountLinkRequestedEvent event) {
    SocialAccount socialAccount = commandSocialAccountService.saveSocialAccount(
            event.provider(),
            event.memberId(),
            event.providerId(),
            event.socialConnectedAt(),
            event.socialEmailAgreed(),
            event.socialNicknameAgreed()
    );
}
 
// profile.application.event.UserProfileEventHandler.java
@EventListener
public void handleUserProfileCreation(UserProfileCreatedEvent event) {
    UserProfile userProfile = commandUserProfileService.saveUserProfile(
            event.memberId(),
            event.nickname()
    );
}
 
// notification.application.event.WelcomeEmailEventHandler.java
@EventListener
public void handleWelcomeEmailSending(WelcomeEmailSentEvent event) {
    messageService.sendWelcomeEmail(event.email());
}

...
private final ApplicationEventPublisher eventPublisher;
 
@Transactional
public PairTokenResponse login(KakaoSocialLoginCommand command) {
    SocialUserProfileResult profile = loadKakaoUserProfilePort.load(command.authorizationCode());
    SocialAccount socialAccount = querySocialAccountService.findExistingSocialAccount(command.provider(), Long.valueOf(profile.providerId()))
                    .orElse(null);
 
    MemberAccount memberAccount;
    if (socialAccount != null) {
        // [Case A] 기존 가입자: 안전하게 기존 객체의 필드 접근
        memberAccount = queryMemberAccountService.findById(socialAccount.getMemberAccountId());
    } else {
        // [Case B] 신규 가입자: 새로운 객체 생성
        memberAccount = MemberAccount.create(profile.email(), MemberRole.USER);
        commandMemberAccountService.save(memberAccount);
 
        // B-1. 이벤트 발생 트리거 함수 호출
        eventPublisher.publishEvent(new SocialAccountLinkRequestedEvent(
            memberAccount.getId(),
            command.provider(),
            profile.providerId(),
            profile.connectedAt(),
            profile.emailAgreed(),
            profile.profileNicknameAgreed()
        ));
 
        // B-2. 이벤트 발생 트리거 함수 호출
        eventPublisher.publishEvent(new UserProfileCreatedEvent(
            memberAccount.getId(),
            profile.nickname()
        ));
 
        // B-3. 이벤트 발생 트리거 함수 호출
        eventPublisher.publishEvent(new WelcomeEmailSentEvent(
            memberAccount.getId(),
            memberAccount.getEmail()
        ));
    }
 
    TokenClaimsRequest claimsRequest = commandTokenService.createTokenClaimsRequest(memberAccount.getId(), memberAccount.getEmail(), memberAccount.getRole());
    return commandTokenService.issueTokenPair(claimsRequest);
}

src/
└── shared-kernel/
    ├── event
    |   └── MemberRegisteredEvent.java
    ├── dto/
    ├── vo/
    └── interface/

public record MemberAccountRegisteredEvent(
    Long memberId,
    String email,          
    String nickname,
    String provider,
    String providerId,
    Instant socialConnectedAt,
    boolean socialEmailAgreed,
    boolean socialNicknameAgreed
) {
}

// account.application.event.SocialAccountEventHandler.java
@EventListener
public void handleSocialAccountCreation(MemberAccountRegisteredEvent event) {
    SocialAccount socialAccount = commandSocialAccountService.saveSocialAccount(
            event.provider(),
            event.memberId(),
            event.providerId(),
            event.socialConnectedAt(),
            event.socialEmailAgreed(),
            event.socialNicknameAgreed()
    );
}
 
// profile.application.event.UserProfileEventHandler.java
@EventListener
public void handleUserProfileCreation(MemberAccountRegisteredEvent event) {
    UserProfile userProfile = commandUserProfileService.saveUserProfile(
            event.memberId(),
            event.nickname()
    );
}
 
// notification.application.event.WelcomeEmailEventHandler.java
@Async
@TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)
public void handleWelcomeEmailSending(MemberAccountRegisteredEvent event) {
    messageService.sendWelcomeEmail(event.email());
}

private final ApplicationEventPublisher eventPublisher;
private final TransactionTemplate transactionTemplate;
 
public PairTokenResponse login(KakaoSocialLoginCommand command) {
    SocialUserProfileResult profile = loadKakaoUserProfilePort.load(command.authorizationCode());
    MemberAccount memberAccount = transactionTemplate.execute(status -> getOrCreateMemberAccount(profile));
    return commandTokenService.issueTokenPair(new TokenClaimsRequest(memberAccount.getId(), memberAccount.getEmail(), memberAccount.getRole()));
}
 
// [파일 내부 트랜잭션 처리] TransactionTemplate 사용
private MemberAccount getOrCreateMemberAccount(SocialUserProfileResult profile) {
    SocialAccount socialAccount = querySocialAccountService.findExistingSocialAccount(profile.provider(), Long.valueOf(profile.providerId()))
                    .orElse(null);
 
    MemberAccount memberAccount;
    if (socialAccount != null) {
        // [Case A] 기존 가입자: 안전하게 기존 객체의 필드 접근
        memberAccount = queryMemberAccountService.findById(socialAccount.getMemberAccountId());
    } else {
        // [Case B] 신규 가입자: 새로운 객체 생성
        memberAccount = MemberAccount.create(profile.email(), MemberRole.USER);
        commandMemberAccountService.save(memberAccount);
 
        // B-1. 이벤트 발생 트리거 함수 호출
        eventPublisher.publishEvent(new MemberAccountRegisteredEvent(
            memberAccount.getId(),
            profile.email(),
            profile.nickname(),
            OAuth2Provider.valueOf(profile.provider()),
            Long.valueOf(profile.providerId()),
            profile.connectedAt(),
            profile.emailAgreed(),
            profile.profileNicknameAgreed()
        ));
    }
 
    return memberAccount;
}

src/
|── shared-kernel/
|   └── event/
|
|──── modules/
|     └── account/
|         ├── adapter/
|         │   └── out/
|         │       └── persistence/
|         │           
|         ├── domain/
|         └── application/
|
└──── common/
     ├── domain/
     |   └── type/
     |       └── AggregateRoot.java
     |       └── DomainAggregateRoot.java
     └── adapter/
         └── out/
             └── persistence/
                 └── jpa/
                     └── BaseInstanceTimeJpaEntity.java
                     └── JpaAggregateRoot.java

// common.domain.type.AggregateRoot.java
public abstract class AggregateRoot {}
 
// common.domain.type.DomainAggregateRoot.java
public abstract class DomainAggregateRoot extends AggregateRoot {
    private final List<Object> domainEvents = new ArrayList<>();
 
    // 이벤트 내부 수집
    protected void registerEvent(Object event) {
        if (event != null) {
            this.domainEvents.add(event);
        }
    }
 
    // 내부에 등록된 모든 도메인 이벤트를 반환하고, 이벤트 저장소를 완전히 초기화(Clear)
    public Collection<Object> pollAllEvents() {
        if (domainEvents.isEmpty()) {
            return Collections.emptyList();
        }
 
        List<Object> currentEvents = new ArrayList<>(this.domainEvents);
        this.domainEvents.clear();
 
        return Collections.unmodifiableCollection(currentEvents);
    }
}

// common.adapter.out.persistence.jpa.BaseInstanceTimeJpaEntity.java
@Getter
@MappedSuperclass
@EntityListeners(AuditingEntityListener.class)
public abstract class BaseInstantTimeJpaEntity {
 
    @Comment("생성 일시")
    @CreatedDate
    @Column(updatable = false, nullable = false, columnDefinition = "DATETIME(6)")
    private Instant createdAt;
 
    @Comment("수정 일시")
    @LastModifiedDate
    @Column(nullable = false, columnDefinition = "DATETIME(6)")
    private Instant updatedAt;
}
 
// common.adapter.out.persistence.jpa.JpaAggregateRoot.java
@MappedSuperclass
public abstract class JpaAggregateRoot extends BaseInstantTimeJpaEntity {
 
    @Transient // DB 컬럼으로 매핑되지 않도록 반드시 선언
    private transient final List<Object> domainEvents = new ArrayList<>();
 
    // POJO 도메인 객체에서 발생한 이벤트를 영속성 엔티티로 전이(이벤트 수집)
    public void recordPersistenceEvent(Object event) {
        if (event != null) {
            this.domainEvents.add(event);
        }
    }
 
     // Repository.save() 호출 시 Spring Data가 이 메서드를 찾아 이벤트를 발행 
     // save() 동작 이후, 자동 수행되는 메서드(이벤트 발행)
    @DomainEvents
    protected Collection<Object> domainEvents() {
        return Collections.unmodifiableList(domainEvents);
    }
 
    // 이벤트 발행 완료 후 리스트를 비워 중복 발행을 방지
    // @DomainEvents 어노테이션이 붙은 메서드가 실행된 이후, 자동 수행되는 메서드
    @AfterDomainEventPublication
    protected void clearDomainEvents() {
        this.domainEvents.clear();
    }
}

// account.domain.MemberAccount.java
@Getter
public class MemberAccount extends DomainAggregateRoot {
    private Long id;
    private String email;
    private String password;
    private MemberRole role;
    private Instant createdAt;
    private Instant updatedAt;
 
    @Builder
    private MemberAccount(
            Long id,
            String email,
            String password,
            MemberRole role,
            Instant createdAt,
            Instant updatedAt
    ) {
        ensureInvariants(email, role);
 
        this.id = id;
        this.email = email;
        this.password = password;
        this.role = role;
        this.createdAt = createdAt;
        this.updatedAt = updatedAt;
    }
 
    // FACTORY METHOD
    public static MemberAccount create(String email, MemberRole role) {
        return MemberAccount.builder()
                .id(TsidCreator.getTsid().toLong())
                .email(email)
                .role(role)
                .build();
    }
 
    // 소셜 계정으로 가입 시, 내부에서 이벤트 발행(적재)
    public static MemberAccount createWithSocialLink(
            String email,
            MemberRole role,
            SocialUserProfileInfo socialUserProfileInfo
    ) {
        MemberAccount newMember = create(email, role);
        newMember.completeSocialRegistration(socialUserProfileInfo);
        return newMember;
    }
 
    // EVENT REGISTER
    // SocialUserProfileInfo의 필드는 수정했다고 가정....
    private void completeSocialRegistration(SocialUserProfileInfo socialUserProfileInfo) {
        ensureSocialLinkInvariants(socialUserProfileInfo);
        registerEvent(new MemberAccountRegisteredEvent(
            this.id,
            this.email,
            socialUserProfileInfo.nickname(),
            OAuth2Provider.valueOf(socialUserProfileInfo.provider()),
            Long.valueOf(socialUserProfileInfo.providerId()),
            socialUserProfileInfo.connectedAt(),
            socialUserProfileInfo.emailAgreed(),
            socialUserProfileInfo.profileNicknameAgreed()
        ));
 
    }
 
    // VALIDATE
    private void ensureInvariants(String email, MemberRole role) {
        // Domain 기본 규칙 강제 코드..
    }
 
    private static void ensureSocialLinkInvariants(SocialUserProfileInfo socialUserProfileInfo) {
        // 소셜 계정 생성 규칙 강제 코드..
    }
}
 
// account.adapter.out.persistence.jpa.MemberAccountJpaEntity.java
@Entity
@Table(name="member_accounts")
@NoArgsConstructor(access = lombok.AccessLevel.PROTECTED)
@Getter
public class MemberAccountJpaEntity extends JpaAggregateRoot implements Persistable<Long> {
    @Id
    private Long id;
 
    @Comment("회원 이메일(로그인 아이디)")
    @Column(updatable = false, unique = true, nullable = false)
    private String email;
 
    @Comment("회원 패스워드")
    @Column(name="password")
    private String password;
 
    @Comment("회원 권한")
    @Enumerated(EnumType.STRING)
    private MemberRole role;
 
    @Builder
    private MemberAccountJpaEntity(
        Long id,
        String email,
        String password,
        MemberRole role,
        Instant createdAt,
        Instant updatedAt
    ) {
        this.id = id;
        this.email = email;
        this.password = password;
        this.role = role;
    }
 
 
    // thinking: 리팩토링 가능할듯...?
    // Spring Data JPA가 save() 시 INSERT를 할지 UPDATE를 할지 판단할 수 있도록 Persistable 인터페이스를 구현
    // => 생성 시간이 없으면 신규 객체로 간주
    @Override
    public boolean isNew() {
        return getCreatedAt() == null;
    }
}

// 원래는 Port를 통해 Adapter구현체를 가져오는 방향으로 작성되어있는데, 편의를 위해 구현체로 작성..
// account.application.command.CommandMemberAccountService.java
@Service
@Transactional
@RequiredArgsConstructor
public class CommandMemberAccountService {
    private final MemberAccountJpaEntityMapper memberAccountJpaEntityMapper;
    private final MemberAccountJpaCommandRepository memberAccountJpaCommandRepository;
 
    @Override
    public MemberAccount save(MemberAccount memberAccount) {
        MemberAccountJpaEntity entity = memberAccountJpaEntityMapper.toJpaEntity(memberAccount);
 
        // Point 1: [Event Bridge] 도메인 이벤트를 꺼내어 영속성 엔티티로 전이
        Collection<Object> domainEvents = memberAccount.pollAllEvents();
        if (domainEvents != null && !domainEvents.isEmpty()) {
            domainEvents.forEach(entity::recordPersistenceEvent);
            // 사실, 반드시 동작하는 비즈니스 규칙 플로우 이벤트라면... 예외처리를 해주는 것이 좋을 것 같다.
        }
 
        // Point 2: DB 반영 (Spring Data가 엔티티의 이벤트를 자동 발행)
        MemberAccountJpaEntity savedEntity = memberAccountJpaCommandRepository.save(entity);
 
        return memberAccountJpaEntityMapper.toDomain(savedEntity);
    }
}
 
// account.adapter.out.persistence.jpa.MemberAccountJpaCommandRepository.java
public interface MemberAccountJpaCommandRepository extends Repository<MemberAccountJpaEntity, Long> {
}

private final TransactionTemplate transactionTemplate;
 
public PairTokenResponse login(KakaoSocialLoginCommand command) {
    SocialUserProfileResult profile = loadKakaoUserProfilePort.load(command.authorizationCode());
    MemberAccount memberAccount = transactionTemplate.execute(status -> getOrCreateMemberAccount(profile));
    return commandTokenService.issueTokenPair(new TokenClaimsRequest(memberAccount.getId(), memberAccount.getEmail(), memberAccount.getRole()));
}
 
// [파일 내부 트랜잭션 처리] TransactionTemplate 사용
private MemberAccount getOrCreateMemberAccount(SocialUserProfileResult profile) {
    SocialAccount socialAccount = querySocialAccountService.findExistingSocialAccount(profile.provider(), Long.valueOf(profile.providerId()))
                    .orElse(null);
 
    MemberAccount memberAccount;
    if (socialAccount != null) {
        // [Case A] 기존 가입자: 안전하게 기존 객체의 필드 접근
        memberAccount = queryMemberAccountService.findById(socialAccount.getMemberAccountId());
    } else {
        // [Case B] 신규 가입자: 새로운 객체 생성
        SocialUserProfileInfo socialUserProfileInfo = {....}
        memberAccount = MemberAccount.createWithSocialLink(profile.email(), MemberRole.USER, socialUserProfileInfo);
        commandMemberAccountService.save(memberAccount);
    }
 
    return memberAccount;
}