refactor: 프로필 생성 이벤트에 추천용 스냅샷 추가

Dimo-2562 · Dimo-2562 · commit 231a184c85d7 · 2026-06-03T12:17:56.000+09:00
diff --git a/src/main/java/com/techfork/domain/recommendation/listener/PersonalizedProfileGeneratedEventListener.java b/src/main/java/com/techfork/domain/recommendation/listener/PersonalizedProfileGeneratedEventListener.java
@@ -24,7 +24,11 @@ public void handle(PersonalizedProfileGeneratedEvent event) {
 
         try {
             User user = userLookupService.getUserOrThrow(userId);
-            int recommendationCount = recommendationService.generateRecommendationsForUser(user);
+            int recommendationCount = recommendationService.generateRecommendationsForUser(
+                    user,
+                    event.profileVector(),
+                    event.keyKeywords()
+            );
 
             log.info("Recommendations generated after personalization profile creation for userId: {} - {} recommendations created",
                     userId, recommendationCount);
diff --git a/src/main/java/com/techfork/domain/recommendation/service/LlmRecommendationService.java b/src/main/java/com/techfork/domain/recommendation/service/LlmRecommendationService.java
@@ -67,8 +67,6 @@ public class LlmRecommendationService implements RecommendationService {
 
     @Override
     public int generateRecommendationsForUser(User user) {
-        log.info("사용자 {} 추천 생성 시작", user.getId());
-
         Optional<PersonalizationProfileDocument> personalizationProfileOpt =
                 personalizationProfileDocumentRepository.findByUserId(user.getId());
         if (personalizationProfileOpt.isEmpty() || personalizationProfileOpt.get().getProfileVector() == null) {
@@ -77,11 +75,27 @@ public int generateRecommendationsForUser(User user) {
         }
 
         PersonalizationProfileDocument personalizationProfile = personalizationProfileOpt.get();
-        float[] personalizationProfileVector = personalizationProfile.getProfileVector();
+        return generateRecommendationsForUser(
+                user,
+                personalizationProfile.getProfileVector(),
+                personalizationProfile.getKeyKeywords()
+        );
+    }
+
+    @Override
+    public int generateRecommendationsForUser(User user, float[] personalizationProfileVector, List<String> keyKeywords) {
+        log.info("사용자 {} 추천 생성 시작", user.getId());
+
+        if (personalizationProfileVector == null) {
+            log.warn("사용자 {}의 개인화 프로필 벡터를 찾을 수 없음. 추천 생성 스킵.", user.getId());
+            return 0;
+        }
+
+        List<String> safeKeyKeywords = keyKeywords == null ? List.of() : keyKeywords;
 
         try {
             // 2. k-NN 검색으로 초기 후보군 가져오기
-            List<MmrCandidate> candidates = searchCandidates(personalizationProfileVector, user);
+            List<MmrCandidate> candidates = searchCandidates(personalizationProfileVector, safeKeyKeywords, user);
 
             if (candidates.isEmpty()) {
                 log.info("사용자 {}의 추천 후보군을 찾을 수 없음", user.getId());
@@ -119,18 +133,16 @@ public int generateRecommendationsForUser(User user) {
         }
     }
 
-    private List<MmrCandidate> searchCandidates(float[] personalizationProfileVector, User user) throws IOException {
+    private List<MmrCandidate> searchCandidates(
+            float[] personalizationProfileVector,
+            List<String> keyKeywords,
+            User user
+    ) throws IOException {
         Set<Long> readPostIds = readPostRepository.findRecentReadPostsByUserIdWithMinDuration(user.getId(), PageRequest.of(0, 1000))
                 .stream()
                 .map(readPost -> readPost.getPost().getId())
                 .collect(Collectors.toSet());
 
-        Optional<PersonalizationProfileDocument> personalizationProfileOpt =
-                personalizationProfileDocumentRepository.findByUserId(user.getId());
-        List<String> keyKeywords = personalizationProfileOpt
-                .map(PersonalizationProfileDocument::getKeyKeywords)
-                .orElse(List.of());
-
         RecommendationProperties.EmbeddingWeights weights = properties.getEmbeddingWeights();
         Query filterQuery = vectorQueryBuilder.createExcludeFilter(readPostIds);
 
diff --git a/src/main/java/com/techfork/domain/recommendation/service/RecommendationService.java b/src/main/java/com/techfork/domain/recommendation/service/RecommendationService.java
@@ -1,6 +1,7 @@
 package com.techfork.domain.recommendation.service;
 
 import com.techfork.useraccount.domain.User;
+import java.util.List;
 
 /**
  * 추천 전략 인터페이스
@@ -15,4 +16,17 @@ public interface RecommendationService {
      * @return 생성된 추천 개수
      */
     int generateRecommendationsForUser(User user);
+
+    /**
+     * 사용자별 개인화 추천 게시글 생성
+     *
+     * <p>이미 생성된 개인화 프로필 스냅샷을 기반으로 추천을 생성합니다.
+     * 프로필 저장 직후 이벤트 소비자가 Elasticsearch refresh 이전 검색 가시성에 의존하지 않도록 사용합니다.</p>
+     *
+     * @param user 추천 대상 사용자
+     * @param personalizationProfileVector 개인화 프로필 벡터
+     * @param keyKeywords 개인화 프로필 핵심 키워드
+     * @return 생성된 추천 개수
+     */
+    int generateRecommendationsForUser(User user, float[] personalizationProfileVector, List<String> keyKeywords);
 }
diff --git a/src/main/java/com/techfork/personalization/application/PersonalizationProfileService.java b/src/main/java/com/techfork/personalization/application/PersonalizationProfileService.java
@@ -2,6 +2,7 @@
 
 import com.techfork.personalization.application.event.PersonalizedProfileGeneratedEvent;
 import com.techfork.personalization.application.generation.PersonalizedProfileGenerator;
+import com.techfork.personalization.infrastructure.PersonalizationProfileDocument;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.context.ApplicationEventPublisher;
@@ -30,8 +31,12 @@ public void generatePersonalizationProfile(Long userId) {
     @Transactional
     public void generatePersonalizationProfileSync(Long userId) {
         try {
-            personalizedProfileGenerator.generate(userId);
-            eventPublisher.publishEvent(new PersonalizedProfileGeneratedEvent(userId));
+            PersonalizationProfileDocument profileDocument = personalizedProfileGenerator.generate(userId);
+            eventPublisher.publishEvent(new PersonalizedProfileGeneratedEvent(
+                    userId,
+                    profileDocument.getProfileVector(),
+                    profileDocument.getKeyKeywords()
+            ));
 
             log.info("Personalization profile generated successfully for userId: {}", userId);
 
diff --git a/src/main/java/com/techfork/personalization/application/event/PersonalizedProfileGeneratedEvent.java b/src/main/java/com/techfork/personalization/application/event/PersonalizedProfileGeneratedEvent.java
@@ -1,6 +1,19 @@
 package com.techfork.personalization.application.event;
 
+import java.util.List;
+
 public record PersonalizedProfileGeneratedEvent(
-        Long userId
+        Long userId,
+        float[] profileVector,
+        List<String> keyKeywords
 ) {
+    public PersonalizedProfileGeneratedEvent {
+        profileVector = profileVector == null ? null : profileVector.clone();
+        keyKeywords = keyKeywords == null ? List.of() : List.copyOf(keyKeywords);
+    }
+
+    @Override
+    public float[] profileVector() {
+        return profileVector == null ? null : profileVector.clone();
+    }
 }
diff --git a/src/test/java/com/techfork/domain/recommendation/listener/PersonalizedProfileGeneratedEventListenerTest.java b/src/test/java/com/techfork/domain/recommendation/listener/PersonalizedProfileGeneratedEventListenerTest.java
@@ -13,8 +13,14 @@
 import org.springframework.transaction.event.TransactionPhase;
 import org.springframework.transaction.event.TransactionalEventListener;
 
+import java.util.Arrays;
+import java.util.List;
+
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatCode;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.argThat;
+import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.BDDMockito.given;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.verify;
@@ -37,29 +43,49 @@ class PersonalizedProfileGeneratedEventListenerTest {
     void handle_GeneratesRecommendationsWhenProfileGeneratedEventIsReceived() {
         Long userId = 1L;
         User user = mock(User.class);
+        float[] profileVector = new float[]{0.1f, 0.2f};
+        List<String> keyKeywords = List.of("Spring", "JPA");
         given(userLookupService.getUserOrThrow(userId)).willReturn(user);
-        given(recommendationService.generateRecommendationsForUser(user)).willReturn(5);
+        given(recommendationService.generateRecommendationsForUser(
+                eq(user),
+                any(float[].class),
+                eq(keyKeywords)
+        )).willReturn(5);
 
-        listener.handle(new PersonalizedProfileGeneratedEvent(userId));
+        listener.handle(new PersonalizedProfileGeneratedEvent(userId, profileVector, keyKeywords));
 
         verify(userLookupService).getUserOrThrow(userId);
-        verify(recommendationService).generateRecommendationsForUser(user);
+        verify(recommendationService).generateRecommendationsForUser(
+                eq(user),
+                argThat(vector -> Arrays.equals(vector, profileVector)),
+                eq(keyKeywords)
+        );
     }
 
     @Test
     @DisplayName("추천 생성이 실패해도 예외를 전파하지 않는다")
     void handle_RecommendationFailureDoesNotPropagateException() {
         Long userId = 2L;
         User user = mock(User.class);
+        float[] profileVector = new float[]{0.1f, 0.2f};
+        List<String> keyKeywords = List.of("Spring", "JPA");
         given(userLookupService.getUserOrThrow(userId)).willReturn(user);
-        given(recommendationService.generateRecommendationsForUser(user))
+        given(recommendationService.generateRecommendationsForUser(
+                eq(user),
+                any(float[].class),
+                eq(keyKeywords)
+        ))
                 .willThrow(new RuntimeException("recommendation failure"));
 
-        assertThatCode(() -> listener.handle(new PersonalizedProfileGeneratedEvent(userId)))
+        assertThatCode(() -> listener.handle(new PersonalizedProfileGeneratedEvent(userId, profileVector, keyKeywords)))
                 .doesNotThrowAnyException();
 
         verify(userLookupService).getUserOrThrow(userId);
-        verify(recommendationService).generateRecommendationsForUser(user);
+        verify(recommendationService).generateRecommendationsForUser(
+                eq(user),
+                argThat(vector -> Arrays.equals(vector, profileVector)),
+                eq(keyKeywords)
+        );
     }
 
     @Test
@@ -69,7 +95,7 @@ void handle_UserLookupFailureDoesNotPropagateExceptionAndSkipsRecommendation() {
         given(userLookupService.getUserOrThrow(userId))
                 .willThrow(new RuntimeException("user lookup failure"));
 
-        assertThatCode(() -> listener.handle(new PersonalizedProfileGeneratedEvent(userId)))
+        assertThatCode(() -> listener.handle(new PersonalizedProfileGeneratedEvent(userId, new float[]{0.1f}, List.of("Spring"))))
                 .doesNotThrowAnyException();
 
         verify(userLookupService).getUserOrThrow(userId);
diff --git a/src/test/java/com/techfork/domain/recommendation/service/LlmRecommendationServiceTest.java b/src/test/java/com/techfork/domain/recommendation/service/LlmRecommendationServiceTest.java
@@ -43,6 +43,7 @@
 import static org.mockito.ArgumentMatchers.same;
 import static org.mockito.BDDMockito.given;
 import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
 
@@ -172,7 +173,7 @@ void generateRecommendationsForUser_UsesPersonalizationProfileProjectionVectorAn
         assertThat(candidatesCaptor.getValue())
                 .extracting(MmrService.MmrCandidate::getPostId)
                 .containsExactly(501L, 502L);
-        verify(personalizationProfileDocumentRepository, times(2)).findByUserId(userId);
+        verify(personalizationProfileDocumentRepository, times(1)).findByUserId(userId);
         verify(vectorQueryBuilder).createKnnSearches(
                 eq("titleEmbedding"),
                 eq("summaryEmbedding"),
@@ -188,6 +189,43 @@ void generateRecommendationsForUser_UsesPersonalizationProfileProjectionVectorAn
         verify(vectorQueryBuilder).createBm25Query(List.of("Spring", "JPA"), 0.6f, 0.2f, 0.2f);
     }
 
+    @Test
+    @DisplayName("프로필 스냅샷 기반 추천 생성은 PersonalizationProfileDocument를 다시 조회하지 않는다")
+    void generateRecommendationsForUser_WithProfileSnapshot_DoesNotReadPersonalizationProfileProjection() throws IOException {
+        Long userId = 10L;
+        User user = createUser(userId);
+        float[] profileVector = new float[]{0.1f, 0.2f};
+        List<String> keyKeywords = List.of("Spring", "JPA");
+        Query filterQuery = Query.of(query -> query.matchAll(matchAll -> matchAll));
+        Query bm25Query = Query.of(query -> query.matchAll(matchAll -> matchAll));
+
+        given(readPostRepository.findRecentReadPostsByUserIdWithMinDuration(userId, PageRequest.of(0, 1000)))
+                .willReturn(List.of());
+        given(vectorQueryBuilder.createExcludeFilter(Set.of())).willReturn(filterQuery);
+        given(vectorQueryBuilder.createKnnSearches(
+                eq("titleEmbedding"),
+                eq("summaryEmbedding"),
+                eq("contentChunks.embedding"),
+                same(profileVector),
+                eq(0.6f),
+                eq(0.2f),
+                eq(0.2f),
+                eq(50),
+                eq(150),
+                same(filterQuery)
+        )).willReturn(List.of());
+        given(vectorQueryBuilder.createBm25Query(keyKeywords, 0.6f, 0.2f, 0.2f))
+                .willReturn(bm25Query);
+        given(elasticsearchClient.search(searchRequestBuilder(), eq(PostDocument.class)))
+                .willReturn(emptySearchResponse(), emptySearchResponse());
+
+        int createdCount = llmRecommendationService.generateRecommendationsForUser(user, profileVector, keyKeywords);
+
+        assertThat(createdCount).isZero();
+        verify(personalizationProfileDocumentRepository, never()).findByUserId(any());
+        verify(vectorQueryBuilder).createBm25Query(keyKeywords, 0.6f, 0.2f, 0.2f);
+    }
+
     @Test
     @DisplayName("추천 후보는 Post aggregate가 아니라 PostDocument projection에서 만들어진다")
     void applyRrf_UsesPostDocumentProjectionAsCandidateSource() {
@@ -285,6 +323,19 @@ private SearchResponse<PostDocument> searchResponse(Hit<PostDocument> hit) {
         );
     }
 
+    private SearchResponse<PostDocument> emptySearchResponse() {
+        return SearchResponse.of(response -> response
+                .took(1)
+                .timedOut(false)
+                .shards(shards -> shards
+                        .total(1)
+                        .successful(1)
+                        .failed(0)
+                )
+                .hits(hits -> hits.hits(List.of()))
+        );
+    }
+
     private Hit<PostDocument> hit(String id, double score, PostDocument document) {
         return Hit.of(hit -> hit
                 .id(id)
diff --git a/src/test/java/com/techfork/personalization/application/PersonalizationProfileServiceTest.java b/src/test/java/com/techfork/personalization/application/PersonalizationProfileServiceTest.java
@@ -2,6 +2,8 @@
 
 import com.techfork.personalization.application.event.PersonalizedProfileGeneratedEvent;
 import com.techfork.personalization.application.generation.PersonalizedProfileGenerator;
+import com.techfork.personalization.infrastructure.PersonalizationProfileDocument;
+import java.util.List;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
@@ -33,13 +35,25 @@ class PersonalizationProfileServiceTest {
     @DisplayName("개인화 프로필 생성 성공 후 프로필 생성 이벤트를 발행한다")
     void generatePersonalizationProfileSync_PublishesProfileGeneratedEventAfterProfileGeneration() {
         Long userId = 1L;
+        float[] profileVector = new float[]{0.1f, 0.2f};
+        PersonalizationProfileDocument profileDocument = PersonalizationProfileDocument.create(
+                userId,
+                "Spring과 JPA 기반 백엔드 관심 프로필",
+                profileVector,
+                List.of("Backend"),
+                List.of("Spring", "JPA")
+        );
+        given(personalizedProfileGenerator.generate(userId)).willReturn(profileDocument);
 
         personalizationProfileService.generatePersonalizationProfileSync(userId);
 
         ArgumentCaptor<PersonalizedProfileGeneratedEvent> eventCaptor = ArgumentCaptor.forClass(PersonalizedProfileGeneratedEvent.class);
         verify(personalizedProfileGenerator).generate(userId);
         verify(eventPublisher).publishEvent(eventCaptor.capture());
-        assertThat(eventCaptor.getValue().userId()).isEqualTo(userId);
+        PersonalizedProfileGeneratedEvent event = eventCaptor.getValue();
+        assertThat(event.userId()).isEqualTo(userId);
+        assertThat(event.profileVector()).containsExactly(0.1f, 0.2f);
+        assertThat(event.keyKeywords()).containsExactly("Spring", "JPA");
     }
 
     @Test
